Python学习笔记-入门篇

作者: 陈yc | 来源:发表于2020-07-01 10:44 被阅读0次

安装

mac：

下载相应系统的安装包安装即可（下载地址：https://www.python.org/downloads/）
检验安装成功与否：

$ python3

Linux：

下载源码压缩包：https://www.python.org/downloads/source/

tar -zxvf Python-3.6.1.tgz
cd Python-3.6.1
./configure
make && make install
# 检查 Python3 是否正常可用
python3 -V

其他环境见https://www.runoob.com/python3/python3-install.html

获取帮助文档：

$ python3
$ help(filter)

安装autopep8

安装：$ pip3 install autopep8
进入pycharm菜单Preference - Tools - External Tools
点击+按钮
填写

Name: autopep8
Program: /Library/Frameworks/Python.framework/Versions/3.8/bin/autopep8
Arguments: --in-place --aggressive --aggressive $FilePath$
Working directory: $ProjectFileDir$
Output filters: $FILE_PATH$\:$LINE $\:\$ COLUMN$:.*

基本数据类型

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

不可变数据：Number（数字）、String（字符串）、Tuple（元组）
可变数据：List（列表）、Dictionary（字典）、Set（集合）

多变量赋值：

a = b = c = 1
a, b, c = 1, 1.1, 'abc'

一个变量可以通过赋值指向不同类型的对象

判断数据类型：

type('123')  # <class 'str'>
isinstance(123, int) # True

isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型；
isinstance()会认为子类是一种父类类型。

Number（数字）

支持 int、float、complex（复数）等数值类型
整型是没有限制大小的，可以当作 Long 类型使用
浮点型可以使用科学计数法表示：2.5e2 = 2.5 x 10^2 = 250
复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型
数据类型不允许改变，如改变数字数据类型的值，将重新分配内存空间
在混合计算时，将把整型转换成为浮点数
数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数

数值运算：

5 + 4  # 9
4.3 - 2 # 2.3
3 * 7  # 21
2 / 4  # 0.5，得到一个浮点数
2 // 4 # 0，得到一个整数
17 % 3 # 2，取余 
2 ** 5 # 32，乘方

数值类型转换：

x, y, z, k = 1, 2.5, 0xA0F, 0o37
int(y) # 2
float(x) # 1.0
complex(x) # (1+0j)
complex(x, y) # (1+2.5j)
z # 十六进制，等于2575
k # 八进制，等于31

String（字符串）

字符串用单引号 ' 或双引号 " 括起来
使用三引号('''或""")可以指定一个多行字符串
不支持单字符类型，单字符是作为一个字符串使用
反斜杠可以用来转义，使用r可以让反斜杠不发生转义
字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误

字符串的截取：

str = 'abcd'
str[0] # a
str[1:3] # bc
str[0:-1] # abc
str[1:] # bcd

字符串其他操作：

str = 'abc'
str[a * 3] # abcabcabc，重复
str + 'def' # abcdef，连接
print('abc\ndef')
# abc
# def，\ 转义特殊字符

print(r'abc\ndef') # abc\ndef，字符串前面添加一个 r，表示原始字符串

# 字符串格式化
print ("我叫 %s 今年 %d 岁!" % ('小陈', 28)) # 我叫 小陈 今年 28 岁!

# f-string
name = 'chan'
f'hello {name}' # hello chan
f'{1+2}' # '3'
rect = {'w': 100, 'h': 150}
f'宽度：{rect["w"]}, 高度：{rect["h"]}' # 宽度：100, 高度：150

# 字符串更新
str = 'hello world'
str[:6] + 'chan' # hello chan

List（列表）

和字符串一样，可以被索引和切片
List可以使用+操作符进行拼接
List中的元素是可以改变的
列表截取的语法：变量[头下标:尾下标]

基本操作：

list = [1, 2, 3, 'a', 'b', 'c', 1.1, True]
list2 = [0, 9, 8]

list[1] # 2
list[1:4] # [2, 3, 'a']
list[2:] # [3, 'a', 'b', 'c', 1.1, True]
list * 2 # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 1, 2, 3, 'a', 'b', 'c', 1.1, True]
list + list2 # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 0, 9, 8]

len(list) # 8，获取长度
del list[2] # 删除第三个元素
3 in list # True，元素是否存在于列表中
for x in list: print(x) # 迭代输出
list(tuple) # 将元组转换为列表

list.append('z') # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 'z']，在列表末尾添加新的对象
list.count(2) # 1，统计某个元素在列表中出现的次数
list.extend([5, 6, 7]) # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 'z', 5, 6, 7]，在列表末尾一次性追加另一个序列中的多个值
list.index('a') # 3，从列表中找出某个值第一个匹配项的索引位置
list.insert(6, 'd') # [1, 2, 3, 'a', 'b', 'c', 'd', 1.1, True, 'z', 5, 6, 7]，将对象插入列表
list.pop() # [1, 2, 3, 'a', 'b', 'c', 'd', 1.1, True, 'z', 5, 6]，移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(1.1) # [1, 2, 3, 'a', 'b', 'c', 'd', True, 'z', 5, 6]，移除列表中某个值的第一个匹配项
list.reverse() # [6, 5, 'z', True, 'd', 'c', 'b', 'a', 3, 2, 1]，反向列表中元素
list.sort() # 排序
list2 = list.copy() # 复制列表
list.clear() # []，清空列表

# 遍历获取列表索引
for i, v in enumerate(list):
    print('第', i, '行的值是', v)

# 同时遍历两个数组
people = ['Lily', 'Lucy', 'Sam']
age = [18, 20, 22]
for p, a in zip(people, age):
    print('{0} 的年龄是 {1}'.format(p, a))
# Lily 的年龄是 18
# Lucy 的年龄是 20
# Sam 的年龄是 22

列表推导式：

list = [1, 3, 6]
list2 = [x * x for x in list]
print(list2) 
# [1, 9, 36]
list3 = [[x, x % 2] for x in list]
print(list3) 
# [[1, 1], [3, 1], [6, 0]]
list4 = ['chi', '   chi ', 'chi   ']
list5 = [x.strip() for x in list4]
print(list5) 
# ['chi', 'chi', 'chi']
list6 = [x for x in list if x > 2]
print(list6) 
#  [3, 6]
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
matrix2 = [[row[i] for row in matrix] for i in range(4)]
print(matrix2)
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
# 3X4的矩阵列表转换为4X3列表

Tuple（元组）

与列表类似，不同之处在于元组的元素不能修改
元组写在小括号 () 里，元素之间用逗号隔开
只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

基本操作：

tuple = (1, 2, 3, 'a', 'b', 'c')
tuple2 = 4, 5, 6, 'd', 'e', 'f' # 不用括号也可以
tuple3 = (10)
tuple4 = (10,)
type(tuple2) # <class 'tuple'>
type((tuple3) # <class 'int'>
type((tuple4) # <class 'tuple'>
len(tuple) # 6
tuple4 * 5 # (10, 10, 10, 10, 10)
for x in tuple: print(x) # 迭代输出
tuple(list) # 将列表转为元组
del tuple # 删除

Dict 字典

字典是一种可变容器模型，且可存储任意类型对象
格式：d = {key1 : value1, key2 : value2 }
键必须是唯一且不可变，可以用数字，字符串或元组，列表不行
如果同一个键被赋值两次，以后一个为准
值可以取任何数据类型

基本操作：

dict = {
    'name': 'cyc',
    'age': 28
}
dict2 = { 'cyc': 'good' }

dict['name'] # cyc
dict['age'] # 28
dict['sex'] = 'male' # {'name': 'cyc', 'age': 28, 'sex': 'male'}
del dict['sex'] # 删除元素，{'name': 'cyc', 'age': 28}
dict[3] = 'c' # 键可以是数字

dict.get('age') # 28
len(dict) # 3，获取元素个数
str(dict) # 转字符串，{'name': 'cyc', 'age': 28, 3: 'c'}
'name' in dict # True，是否有该键

list(dict.keys()) # ['name', 'age', 3]
list(dict.values()) # ['cyc', 28, 'c']
list(dict.items()) # [('name', 'cyc'), ('age', 28), (3, 'c')]

dict.copy() # 浅复制
dict.update(dict2) # {'name': 'cyc', 'age': 28, 3: 'c', 'cyc': 'good'}，把字典dict2的键/值对更新到dict里
dict.pop('name') # cyc，删除字典给定键 key 所对应的值，返回值为被删除的值
dict.popitem() # ('cyc', 'good')，返回并删除字典中的最后一对键和值

dict.clear() # 清空字典
del(dict) # 删除字典

dict2 = dict2.fromkeys(('Tom', 'Ben', 'Sam'), 10) 
# {'Tom': 10, 'Ben': 10, 'Sam': 10}
# 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

# 元组列表转字典
dict = dict([('Lucy', 18), ('Lily', 20), ('Ben', 22)])
print(dict) # {'Lucy': 18, 'Lily': 20, 'Ben': 22}
# 遍历技巧
for k, v in dict.items():
    print(k, "is ", v, ' age years old')
# Lucy is  18  age years old
# Lily is  20  age years old
# Ben is  22  age years old

字典推导式：

square = {x : x * x for x in (2, 4, 6)}
print(square) # {2: 4, 4: 16, 6: 36}

Set 集合

是一个无序的不重复元素序列
使用大括号 { } 或者 set() 函数创建集合
创建一个空集合必须用 set() 而不是 { }

基本操作

fruit = {'apple', 'banana', 'lemon', 'orange'}
print('apple' in fruit) # True，判断是否存在与集合中

set1 = set('abcdefg') # {'f', 'd', 'c', 'a', 'b', 'e', 'g'}
set2 = set('efgh') # {'h', 'e', 'g', 'f'}
set1 - set2 # {'a', 'b', 'd', 'c'}，集合set1中包含而集合set2中不包含的元素
set1 | set2 # {'f', 'h', 'd', 'b', 'a', 'c', 'e', 'g'}，集合set1或set2中包含的所有元素
set1 & set2 # {'e', 'g', 'f'}，集合set1和set2中都包含了的元素
set1 ^ set2 # {'h', 'd', 'c', 'a', 'b'}，不同时包含于set1和set2的元素
set2.add('ij') # {'f', 'h', 'e', 'g', 'ij'}，添加元素

set3 = set(('Tom', 'Ben', 'Sam')) # {'Ben', 'Tom', 'Sam'}
set3.update({'Lily', 'Lucy'}) # {'Tom', 'Sam', 'Ben', 'Lily', 'Lucy'}，添加元素
set3.update(['Kaka', 'Fango'], ['Trump', 'Bush']) # {'Fango', 'Bush', 'Kaka', 'Sam', 'Ben', 'Lily', 'Lucy', 'Tom', 'Trump'}，添加元素
len(set3) # 9，获取集合元素个数
set3.remove('Trump') # 删除元素，元素不存在会报错
set3.discard('Bush') # 删除元素，元素不存在也不会报错
print(set3.pop()) # 随机删除一个元素，并返回该元素
set3.clear() # set()，情况集合

集合推导式：

set1 = {x for x in 'chenyuchi' if x not in 'chen'}
print(set1) # {'u', 'i', 'y'}

条件控制

每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块
Python中没有switch – case语句

if 1 == 1:
    print(True)
print(False)

# if 1 == 2 and 1 != 2:
# if 1 == 2 or 1 != 2:
# if not 1 == 2:
# if 1 in [1, 2, 3]:
# if 1 not in [1, 2, 3]

a = 0
while a < 10:
    if a % 2 == 0:
        print(a, '是偶数')
    else:
        print(a, '是奇数')
    a += 1

age = int(input("你几岁？: "))
if age < 28:
    print("你比我小！")
elif age == 28:
    print("跟我一样！")
elif age > 28:
    print("你比我大")

# 退出提示
input("点击 enter 键退出")

循环语句

Python 中有while和for等循环语句，没有 do..while 循环

# 计算从 0 加到 100 之和
i, sum = 0, 0
while i < 100:
    i += 1
    sum += i
print(sum) # 5050

# while...else语句
x = 0
while x < 10:
    print('%d小于10' % x)
    x += 1
else:
    print('%d大于10' % x)

# 循环遍历列表
people = ['Ben', 'Lucy', 'Lily', 'Sam']
for x in people:
    print(x)
# break语句
for y in people:
    print(y)
    if 'L' in y:
        print('名字有L，break')
        break
# continue语句
for y in people:
    if 'L' in y:
        print('名字有L，不输出')
        continue
    print(y)

# range函数，会生成数列
for i in range(5):
    print(i, end()) # 0,1,2,3,4

for i in range(5, 9):
    print(i) # 5,6,7,8

for i in range(0, 10, 3):
    print(i) # 0,3,6,9

for i in range(len(people)):
    print(i, people[i]) # 0 Ben,1 Lucy,2 Lily,3 Sam

list = list(range(5)) # [0, 1, 2, 3, 4]

# pass是空语句，是为了保持程序结构的完整性。
# pass不做任何事情，一般用做占位语句
for letter in 'chenyuchi':
    if letter == 'y':
        pass
        print('执行 pass 块')
    print('当前字母 :', letter)

函数

不带表达式的return相当于返回 None

# 简单示例
def area(width, height):
    return width * height
w = 4
h = 5
print('宽为', w, '，高为', h, '的长方形，面积是 ', area(w, h))
# 宽为 4 ，高为 5 的长方形，面积是  20

# 不带return
def func():
  a = 0
print(func()) # None，不带表达式的return相当于返回 None

# 参数为不可变类型
# 如 整数、字符串、元组，传递的只是x的值，没有影响x对象本身，只是修改另一个复制的对象
def setVal(x):
    x += 1
    print(x) # 1
x = 0
setVal(x)
print(x) # 0

# 参数为可变类型
# 如 列表，字典，函数内修改后外部的变量也会受影响
def setList(list):
    list.append(['a', 'b', 'c'])
    print(list) # [1, 2, 3, ['a', 'b', 'c']]
list = [1, 2, 3]
setList(list)
print(list) # [1, 2, 3, ['a', 'b', 'c']]

参数：

必需参数：须以正确的顺序传入函数。调用时的数量必须和声明时的一样
关键字参数
默认参数
不定长参数

def func1(str, num): 
  print(str, num)
# str和num为必传参数，调用时数量和顺序必须和声明时的一样

def func2(str, num, arg = 30):
    print(str, num, arg)
func(num=10, str='abc') # abc 10 30
# str和num为关键字参数，调用时顺序可与申明时不一样，arg为默认参数

def func3(arg1, arg2, *others):
    print(arg1, arg2, others)
func2(1, 2, 3, 4, 5) # 1 2 (3, 4, 5)
# 不定长参数，前面用*号开头，带*号参数会以元组的形式导入，存放所有未命名的变量参数

def func4(arg1, arg2, **others):
    print(arg1, arg2, others)
func3(1, 2, a=3, b=4, c=5) # 1 2 {'a': 3, 'b': 4, 'c': 5}
# 前面用**号开头的，会以字典的形式导入

def func5(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
# 强制位置参数
# a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参
# f(10, 20, 30, d=40, e=50, f=60)，正确
# f(10, b=20, c=30, d=40, e=50, f=60) 错误，b不能使用关键字参数的形式
# f(10, 20, 30, 40, 50, f=60)，错误，e必须使用关键字参数的形式

匿名函数：

使用 lambda 来创建匿名函数

lambda的主体是一个表达式，而不是一个代码块
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
语法：lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 30)) # 40

iter 迭代器：

list = [1, 2, 3]
it = iter(list)
print(next(it)); # 1
print(next(it)); # 2

yield语句：

def frang (start, stop, step):
    x = start
    while x < stop:
        yield x
        x += step

for i in frang(0, 5, 0.5):
    print(i, end=',')
# 0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5

常用内置函数：

l = [1, 2, 3, 4, 5, 6 , 7, 8, 9, 10]
# filter
l2 = list(filter(lambda x : x > 5, l))
print(l2) # [6, 7, 8, 9, 10]
# map
l3 = list(map(lambda x : x * 10, l))
print(l3) # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
# reduce
l4 = reduce(lambda x, y : x + y, l, 1)
print(l4) # 56
# zip
t = (1, 2, 3)
t2 = (4, 5, 6)
for i in zip(t, t2):
    print(i)
# (1, 4)
# (2, 5)
# (3, 6)
d = {'a': 'aa', 'b': 'bb'}
d2 = zip(d.values(), d.keys())
print(dict(d2))
# {'aa': 'a', 'bb': 'b'}

闭包：

def counter(start = 0):
    l = [start]
    def addOne() :
        l[0] += 1
        return l[0]
    return addOne
num5 = counter(5)
num10 = counter(10)
print(num5()) # 6
print(num5()) # 7
print(num10()) # 11
print(num10()) # 12
print(num10()) # 13

def line_func(a, b):
    return lambda x : a * x + b
line1 = line_func(3, 5)
line2 = line_func(5, 8)
print(line1(10))
print(line2(10))

装饰器：

import time

def timer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('程序运行了 %f 秒' % (end_time - start_time))
    return wrapper

@timer
def mySleep():
    time.sleep(3)

mySleep()

def communicate(word):
    def do(func):
        def wrapper(name, something):
            print(word, end=',')
            print(name, end=' ')
            func(name, something)
            print(something)
        return wrapper
    return do

@communicate('hello')
def eat(name, something):
    print('is eating', end=' ')

@communicate('good moring')
def find(name, something):
    print('is finding', end=' ')

eat('Tom', 'apple') # hello,Tom is eating apple
find('Ben', 'a pen') # good moring,Ben is finding a pen

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。

import 语句

import module1[, module2[,... moduleN]
# 使用别名
import time as t

from … import 语句

# from modname import name1[, name2[, ... nameN]]
from fibo import fib, fib2
fib(500)

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间

from modname import *

name属性

if __name__ == '__main__':
   print('程序自身运行')
else:
   print('在其他模块运行')

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称

import my_module
my_module.hello('Ben')
print(dir(my_module))
# ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'bye', 'hello', 'morning']

包（package）

包是一种管理 Python 模块命名空间的形式
目录只有包含一个叫做 init.py 的文件才会被认作是一个包

import pA.pAA.mA
pA.pAA.mA.afternoon('Tom')
# 必须使用全名去访问

from pA.pAA import mA
mA.afternoon('Tom')

from pA.pAA.mA import afternoon
afternoon('Tom')

File文件

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

filename：文件名称的字符串值
mode：打开文件的模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型

mode	解释
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

f = open('file.text', 'w+')
f.read(size) # 读取一定数目的数据
f.readline() # 读取整行，包括 "\n" 字符，如果返回一个空字符串, 说明已经已经读取到最后一行
f.readlines(sizehint,) # 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区
f.write('123') # 写入字符串到文件中, 返回写入的字符数
f.writelines(sequence) # 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符
f.tell() # 返回文件对象当前所处的位置, 从文件开头开始算起的字节数
f.seek(5) # 移动到文件的第六个字节
f.seek(-3, 2) # 移动到文件的倒数第三字节
f.flush() # 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
f.close() # 关闭文件并释放系统的资源

错误和异常

try/except 异常处理

try:
  x = int(input("请输入一个数字: "))
except ValueError:
  print("您输入的不是数字，请再次尝试输入！") 

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS 错误: {0}".format(err))
except ValueError:
    print("无法将数据转换为整型")
except:
    print("其他错误:", sys.exc_info()[0])
    raise

try/except...else

else 子句将在 try 子句没有发生任何异常的时候执行

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('打开不了', arg)
    else:
        print(arg, '内容为：', len(f.readlines()), 'lines')
        f.close()

try-finally

无论是否发生异常都将执行最后的代码

抛出异常

raise [Exception [, args [, traceback]]]

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

面向对象

声明类：

class Animal():
    # 构造函数
    def __init__(self, color, food): # self代表类的实例，而非类
        self.color = color
        self.food = food
    # 类方法
    def move(self):
        print('I can move')
    def getInfo(self):
        print('This animal is %s, eats %s' %(self.color, self.food))

私有变量和私有方法以两个下划线开头

实例化：

tiger = Animal('yello', 'meat')
tiger.getInfo() # This animal is yello, eats meat

继承 & 方法重写：

class Cat(Animal):
    def __init__(self, color, food):
        super().__init__(color, food)
    def move(self): # 方法重写
        print('Of couse, I can move!')
    def catch_mouse(self):
        print('I can catch mouse')
cat = Cat('black', 'fish and mouse')
cat.getInfo() # This animal is black, eats fish and mouse
cat.catch_mouse() # I can catch mouse
cat.move() # Of couse, I can move!
super(Cat, cat).move() # I can move , 调用父类已被覆盖的方法

# 多继承：class DerivedClassName(Base1, Base2, Base3):

pip源的设置和使用

$ cd ~
$ mkdir .pip
$ vi pip.conf

编辑pip.conf文件内容：

[global]
timeout=30000
index-url=http://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host=mirrors.aliyun.com

临时配置：

$ pip3 -i http://mirrors.aliyun.com/pypi/simple/ install XXX

Python学习笔记-入门篇

相关网站

安装

mac：

Linux：

获取帮助文档：

安装autopep8

基本数据类型

多变量赋值：

判断数据类型：

Number（数字）

数值运算：

数值类型转换：

String（字符串）

字符串的截取：

字符串其他操作：

List（列表）

基本操作：

列表推导式：

Tuple（元组）

基本操作：

Dict 字典

基本操作：

字典推导式：

Set 集合

基本操作

集合推导式：

条件控制

循环语句

函数

参数：

匿名函数：

iter 迭代器：

yield语句：

常用内置函数：

闭包：

装饰器：

模块

import 语句

from … import 语句

from … import * 语句

__name__属性

dir() 函数

包（package）

File文件

错误和异常

try/except 异常处理

try/except...else

try-finally

抛出异常

面向对象

声明类：

实例化：

继承 & 方法重写：

pip源的设置和使用

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

视觉艺术

name属性