Python语法快速入门

文件结构

一个 Python 源文件的结构主要分成三个部分：头部区域、导入区域、业务代码区域。

头部区域和导入区域需要一个空行，导入区域和业务代码区域需要两个空行，这并不是语法要求，这只是强烈推荐的代码规范！

# coding:utf-8

import os

print(os.getcwd())

代码注释

Python 中有3种注释，其实也可以说是2种：

# 单行注释

"""
一对3个双引号的多行注释
"""

'''
一对3个单引号的多行注释
'''

程序入口

Python 也有类似 C 语言中的程序入口 main 主函数。

# coding:utf-8

import os

if __name__ == '__main__':
    print(os.getcwd())

执行顺序

Python 是自上而下依次解析执行的，这也就可以说明 Python 并不一定需要 main 主函数。但是建议都使用 main 主函数，并且放在程序最底部。然后在 main 主函数中调用它上面的代码，使代码结构更加清晰和利于维护。

后面笔记为了节省篇幅，不会编写完整规范的结构，只会贴出重点部分的代码！

代码缩进

Python 并没有和其他多数编程语言一样用 {} 将代码块括起来，它是通过代码缩进来区分代码块的，缩进使用一个 tab。

比如下面的代码，两个 print 并不是在同一个代码块内，第二个 print 是和 if 对齐，他们是在同一个代码块。

# coding:utf-8

import os

if __name__ == '__main__':
    print(os.getcwd())
print('我回到了一级代码块')

input函数

input 函数的作用类似于 C 语言中的 scanf 函数，接收一个标准输入数据，返回为 string 类型。

result = input('请输入任意内容:')
print(result)

执行结果：

请输入任意内容:hello input
hello input

变量

命名规则

• 变量名由字母、数字和下划线组成，不能以数字开头，并且区分大小写。

• 如果变量名需要多个部分组成，建议使用下划线分割，而不是驼峰命名。

• 不用使用关键字。

name = '小胖'
age = 20
is_sleep = True
a, b, c = 1, 2, 'c'

print(name)
print(age)
print(is_sleep)
print(c)

关键字

数据类型

Python 会自动推导类型，定义变量的时候不一定需要使用类型函数。

数字类型

数字类型有：整型(int) 和 浮点型(float) 类型，在 Python2 中还有 long 类型，在 Python3 被弃用。

# 整型
count_01 = int(1)
count_02 = 1

# 浮点型
pi_01 = float(3.14)
pi_02 = 3.14

字符串类型

一对单引号或一对双引号包裹起来的内容，就是字符串。在 Python 中，使用 str 来代表字符串类型。

字符串不是数字不能做减法、乘除法。字符串的拼接用 +。

name = str('小胖')
info = '小胖很瘦'

用多行注释的三个引号的写法，可以定义保持原格式的字符串：

info = '''
    随便，还保持原格式
 随便来
'''
print(info)

打印结果：

    随便，还保持原格式
 随便来

布尔类型

布尔类型只有两个固定值，True 和 False，分别表示逻辑真、逻辑假。

int 0 是 False，非 0 是 True。

float 0.0 是 False，非 0.0 是 True。

str ''（空字符串） 是 False，非 '' 是 True。

list []（空列表）是 False，非 [] 是 True。

tuple ()（空元组）是 False，非 () 是 True。

dict {}（空字典）是 False，非 {} 是 True。

空类型

不属于任何数据类型，就是空类型。

固定值：None，空类型属于 False 范畴。

如果不确定数据的类型，可以先定义为空类型。

列表类型

列表就是队列，他是各种数据类型的集合，是一种有序的结构，且内容可重复的集合类型。

类似很多语言中的数组集合，比如 Java 中的 List，Objective-C 中的 NSArray。

在 Python 中，列表中的元素存在于中括号 [] 内，元素的类型可以不同。

names_01 = list(['小白', '小胖'])
names_02 = ['小芳', '小美']

# 列表中元素的数据类型可以不同
mix_array = ['小花', 1, 3.14, True, None]

# 判断列表中是否存在某个元素
result = 3.14 in mix_array

# max和min可以获取列表中最大和最小的元素，但数据类型需要一致
max_value = max([1, 2, 3, 4])
min_value = min([1, 2, 3, 4])

元组类型

元组与列表有些特性很像，都是一种可以存储多种数据结构的队列，并且也是有序的，且元素可以重复的集合。

在 Python 中，tuple 代表着元组这种类型，也可以用它定义一个元组。元组的元素存在于一对小括号 () 中。

元组比列表占用资源更小，列表是可变的，元组是不可变的。

元组如果只有一个元素，也必须加上 , 号，否则 Python 解析器无法识别元组。

names_01 = tuple(('小白', '小胖'))
names_02 = ('小芳', '小美')
names_03 = ('小花',) # 只有一个元素，需要加,

# 元组中元素的数据类型可以不同
mix_tuple = ('小花', 1, 3.14, True, None)

# 判断元组中是否存在某个元素
result = 3.14 in mix_tuple

# max和min可以获取元组中最大和最小的元素，但数据类型需要一致
max_value = max((1, 2, 3, 4))
min_value = min((1, 2, 3, 4))

字典类型

Python 中用 dict 来代表字典，并且可以创建一个字典。字典的元素（键值对）存在一对大括号 {} 中。

key 支持字符串、数字和元组类型，但不支持列表。在一个字典中 key 是唯一的。

value 支持 Python 的所有数据类型。

Python3.7 以前，字典是无序的。

person = {'name': '小花', 'age': 99}
test1 = {1: 'one', 2: 'two'}
test2 = {(1, 2, 3): [1, 2, 3], (4, 5, 6): [4, 5, 6]}

# 字典中key可以是不同数据类型
mix_dict = {1: '1', '1': 1}

# 判断字典中是否存在某个key
result = 1 in mix_dict

# max和min可以获取字典中最大和最小的key，但key的数据类型需要一致
max_value = max({1: '1', 2: '2'})
min_value = min({1: '1', 2: '2'})

常用内置函数

print：打印数据，输出到控制台。

type：获取数据类型，类似 C 语言中的 typeof。

id：获取变量的内存地址，类似 C 语言中的 &。

len：返回字符串的长度，类似 C 语言中的 strlen。

max：返回数据中最大的成员。如果是字符串，则中文符号 > 字母 > 数字 > 英文符号。如果是中文，按照拼音首字母来比较。

min：返回数据中最小的成员。比较规则和 max 一致。

dir：返回指定对象的所有方法列表。

in运算符

in：成员运算符用来判断数据是否属于某个数据。

info = 'python是一个好东西'
result = '一个' in info
print(result)

result = '好' not in info
print(result)

打印结果：

True
False

比较运算符

对象

Python 中一切都是对象，每个对象都有各自的属性和方法。

字符串常用方法

capitalize：首字母大写，其他字母如果有大写会转换为小写。

name = 'xiaoFang'
new_name = name.capitalize()
# Xiaofang

casefold 和 lower：都是将字符串中所有字母转为小写。

casefold 是在 Python3.3 引入的，并且支持更多小语种转小写。而 lower 则在很早的版本都可以使用，所以我们平时基本都是使用 lower即可。

name = 'xiaoFang'
new_name = name.casefold()
# xiaofang
new_name = name.lower()
# xiaofang

upper：将字符串中所有字母转为大写。

name = 'xiaoFang'
new_name = name.upper()
# XIAOFANG

swapcase：将字符串中的所有字母大小写反转，也就是是大写的字母会被转为小写，是小写的字母就转为大写。

name = 'xiaoFang'
new_name = name.swapcase()
# XIAOfANG

zfill：为字符串定义长度，如果长度不足则在字符串前填充0。

name = 'xiaoFang'
new_name = name.zfill(10)
# 00xiaoFang

new_name = name.zfill(5) # 如果定义的长度小于当前字符串的长度，则不发生变化
# xiaoFang

count：获取当前字符串中某个成员（元素）的个数，如果不存在则返回0。

注意 count 不是用来获取字符串的长度！如果想要获取字符串的长度，可以使用 len(string) 来获取。

name = 'xiaoFang'
a_count = name.count('a')
# 2

startswith：判断字符串是否以某子字符串开始。

name = 'xiaoFang'
result = name.startswith('x')
# True

endswith：判断字符串是否以某子字符串结束。

name = 'xiaoFang'
result = name.endswith('g')
# True

find：查询某子字符串的位置，返回一个整数，不存在则返回-1。字符串位置是从左向右，以0开始的。

name = 'xiaoFang'
index = name.find('A')
# -1

index：查询某子字符串的位置，返回一个整数，不存在则报错。

name = 'xiaoFang'
index = name.index('A')
# Traceback (most recent call last):
#   File "/Users/feng/Code/PyCharm/demo1/main.py", line 6, in <module>
#     index = name.index('A')
# ValueError: substring not found

strip：去掉字符串左右两边的指定子字符串，不传参默认去掉空格。

name = 'xiaoFang'
result = name.strip('g')
# xiaoFan

lstrip：仅去掉字符串左边的指定子字符串，不传参默认去掉空格。

name = 'xiaoFang'
result = name.lstrip('x')
# iaoFang

rstrip：仅去掉字符串右边的指定子字符串，不传参默认去掉空格。

name = 'xiaoFang'
result = name.rstrip('g')
# xiaoFan

replace：替换字符串中某些子字符串为新的子字符串，并且能指定替换的数量。

name = 'xiaoFang'
result = name.replace('a', '', 1)
# xioFang

isspace：判断字符串是否只由空格组成。

name = 'xiaoFang'
result = name.isspace()
# False

name = ' '
result = name.isspace()
# True

istitle：判断字符串是否是一个标题类型，也就是字符串如果由多个单词组成，并且每个单词只有首字母是大写。只能用于英文。

name = 'xiaoFang'
result = name.istitle()
# False

name = 'XiaoFang'
result = name.istitle()
# False

name = 'Xiaofang'
result = name.istitle()
# True

isupper：判断字符串是否是都是大写。

name = 'XIAOFANG'
result = name.isupper()
# True

islower：判断字符串是否是都是小写。

name = 'xiaofang'
result = name.islower()
# True

join：将序列中的元素以指定的字符连接生成一个新的字符串。

s1 = '-'
seq = ('h', 'e', 'l', 'l', 'o')
result = s1.join(seq)
# h-e-l-l-o

s2 = ''
seq = ['h', 'e', 'l', 'l', 'o']
result = s2.join(seq)
# hello

split：将字符串以指定分隔符拆分成列表。

name = 'xiaoFang xiaoMing'
result = name.split()
# ['xiaoFang', 'xiaoMing']

字符串编码格式

gbk：中文编码。

ascii：英文编码。

utf-8：国际通用的编码格式。

在 Python 源文件头部添加 #coding: 编码格式 即可。

字符串格式化

name = '小芳'
age = 12
height = 1.88

# 利用print函数格式化输出
print('name=%s' % name)
print('age=%d height=%.2f' % (age, height))
# name=小芳
# age=12 height=1.88

# 利用format函数格式化，这种方式支持的格式化符号比较少
print('name={:s}'.format(name))
print('age={:d} height{:.2f}'.format(age, height))
# name=小芳
# age=12 height=1.88

转义字符

字符要转成其他含义的功能，所以我们叫它转义字符。

语法格式：\+字符。

列表与元组常用方法

列表和元组绝大部分内置函数都是一样的。

len：计算除数字类型外的数据长度，比如列表和元组的元素个数。

names = ['xiaofang', 'xiaohua']
print(len(names))
# 2

names = ('xiaofang', 'xiaohua')
print(len(names))
# 2

in：判断某个成员（元素）是否在该数据结构中。

names = ['xiaofang', 'xiaohua']
print(bool('xiaofang' in names))
# True

names = ('xiaofang', 'xiaohua')
print(bool('xiaohua' in names))
# True

not in：判断某个成员（元素）是否不在该数据结构中。

names = ['xiaofang', 'xiaohua']
print(bool('xiaofang' not in names))
# False

names = ('xiaofang', 'xiaohua')
print(bool('xiaohua' not in names))
# False

列表/元组之间的累加与乘法：

names = ['xiaofang', 'xiaohua']
new_names = names + names
print(new_names)
# ['xiaofang', 'xiaohua', 'xiaofang', 'xiaohua']
new_names = names * 2
print(new_names)
# ['xiaofang', 'xiaohua', 'xiaofang', 'xiaohua']

names = ('xiaofang', 'xiaohua')
new_names = names + names
print(new_names)
# ('xiaofang', 'xiaohua', 'xiaofang', 'xiaohua')
new_names = names * 2
print(new_names)
# ('xiaofang', 'xiaohua', 'xiaofang', 'xiaohua')

insert：将一个元素添加到列表指定位置。

names = ['xiaofang', 'xiaohua']
names.insert(0, 'feifei')
# ['feifei', 'xiaofang', 'xiaohua']

append：将一个元素添加到列表结尾。

names = ['xiaofang', 'xiaohua']
names.append('feifei')
# ['xiaofang', 'xiaohua', 'feifei']

count：返回当前列表中的某个成员的个数，不存在则返回0。

fruits = ['苹果', '梨子', '苹果']
print(fruits.count('苹果'))
# 2

remove：删除列表中指定元素，只能删除第一个查找到的元素。

fruits = ['苹果', '梨子', '苹果']
fruits.remove('苹果')
print(fruits)
# ['梨子', '苹果']

del：将变量完全删除，如果后续还继续使用这个变量则会报错。

fruits = ['苹果', '梨子', '苹果']
del fruits

reverse：将当前列表的元素顺序反转。

fruits = ['梨子', '苹果']
fruits.reverse()
# ['苹果', '梨子']

sort：对当前列表按照一定规则进行排序，元素类型要一致，否则报错。

books = ['python', 'django', 'web']

# 降序
books.sort(reverse=True)
print(books)
# ['web', 'python', 'django']

# 升序（默认）
books.sort(reverse=False)
print(books)
# ['django', 'python', 'web']

clear：将当前列表中的数据清空。

books = ['python', 'django', 'web']
books.clear()
# []

copy：将当前列表中的元素复制到一个新的列表。修改新的列表中的元素，不会影响旧的列表，属于深拷贝。

books = ['python', 'django', 'web']
new_books = books.copy()
print('0x%x' % id(books))
print('0x%x' % id(new_books))
# 0x1029b4b00
# 0x1029b4bc0

extend：将其他列表或元组中的元素倒入到当前列表中。

books = ['python', 'django', 'web']
new_books = ['iOS', 'Android']
books.extend(new_books)
# ['python', 'django', 'web', 'iOS', 'Android']

索引与切片

字符串、列表、元组都有索引，起始从0开始，最大索引等于长度减1。

books = ['python', 'django', 'web']
print(books[0])
# python

del books[0]
print(books)
# ['django', 'web']

索引用来对单个元素进行访问，切片则对一定范围内的元素进行访问。切片类似 Swift 中的区间运算符。

切片通过冒号在中括号内把相隔的两个索引查找出来：[3: 8]，切片规则：左含右不含。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers[3: 8])
# [4, 5, 6, 7, 8]

print(numbers[:])
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(numbers[0:])
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(numbers[0: -1])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(numbers[:: -1])
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

print(numbers[-3: -1])
# [8, 9]

print(numbers[0: 8: 2])
# [1, 3, 5, 7]

print(numbers[0: 0])
# []

字典常用方法

字典可以通过 key 来修改和增加元素。

user = {'username': 'dagou', 'age': 12}
user['top'] = 177
print(user)
# {'username': 'dagou', 'age': 12, 'top': 177}

user['username'] = 'gou'
print(user)
# {'username': 'gou', 'age': 12, 'top': 177}

update：添加新的字典，如新字典中有和原字典相同的 key，则该 key 的 value 会被新的字典的 value 覆盖。

user = {'username': 'dagou', 'age': 12}
user.update({'height': 1.9})
# {'username': 'dagou', 'age': 12, 'height': 1.9}

setdefault：获取某个 key 的 value，如 key 不存在于字典中，将会添加 key 并将 value 设为默认值。

default_dict = {}
value = default_dict.setdefault('name', '小芳')
# 小芳

default_dict = {'name': '小花'}
value = default_dict.setdefault('name', '小芳')
# 小花

keys：获取字典所有的 key 的伪列表。

values：获取字典所有的 value 的伪列表。

my_dict = {'name': '小芳', 'age': 12}
keys = my_dict.keys()
values = my_dict.values()
print(keys)
print(values)
print(list(keys))
print(list(values))
# dict_keys(['name', 'age'])
# dict_values(['小芳', 12])
# ['name', 'age']
# ['小芳', 12]

通过 [] 可以根据字典的 key 获取或修改 value 的值。如果 key 不存在，获取则报错。

通过 get 内置函数可以根据字典的 key 获取 value 的值，如果 key 不存在，返回默认值。所以在开发中，优先使用 get 函数来获取数据。

copy：字典深拷贝函数，返回的字典数据相同，地址不同。所以修改新的字典中的数据不会影响旧的字典。

old_dict = {'name': '小芳', 'age': 12}
new_dict = old_dict.copy()
print(old_dict == new_dict)
print(id(old_dict) == id(new_dict))
# True
# False

in 与 not in：判断字典中的 key 是否存在或不存在。

通过 get 函数也可以判断字典中的 key 是否存在。

my_dict = {'name': '小芳', 'age': 12}
print('name' in my_dict)
print('name' not in my_dict)
print(bool(my_dict.get('name')))
# True
# False
# True

popitem：删除当前字典末尾一组键值对并将其返回，返回数据类型为元祖。

my_dict = {'name': '小芳', 'age': 12}
print(my_dict.popitem())
print(my_dict)
# ('age', 12)
# {'name': '小芳'}

集合

set 集合，元素无序且不能重复。

集合无法通过索引获取元素，也无获取元素的任何方法。只是用来处理列表或元祖的一种临时类型，他不适合存储与传输。

a_set = set(['小芳', '小花'])
b_set = {'小芳', '小花'}

集合常用方法

add：添加元素到集合，如果已存在则不执行。

a_set = set()
a_set.add('小芳')
print(a_set)
# {'小芳'}

update：加入一个新的集合（或列表、元祖、字符串），如新集合的元素已存在则无视。

a_set = set()
a_set.update('小米')
a_set.update(['小芳', '小明'])
print(a_set)
# {'米', '小明', '小', '小芳'}

remove：将集合中的某个元素删除，如元素不存在将会报错。

a_set = set('小蜜蜂')
print(a_set)
a_set.remove('小')
print(a_set)

# {'蜜', '蜂', '小'}
# {'蜜', '蜂'}

clear：清空当前集合中的所有元素。

a_set = set('小蜜蜂')
a_set.clear()
print(a_set)
# set()

del：删除集合对象自身，无法删除集合中的元素，因为集合中的元素无索引。

intersection：返回两个或更多集合的交集，也就是每个集合中都存在的元素。

a_set = {'小米', '小兵', '小芳'}
b_set = {'小芳', '小花', '小王'}
print(a_set.intersection(b_set))
# {'小芳'}

union：返回两个或更多集合的并集，也就是包含了所有集合的元素，重复的元素只会出现一次。

a_set = {'小米', '小兵', '小芳'}
b_set = {'小芳', '小花', '小王'}
print(a_set.union(b_set))
# {'小王', '小兵', '小花', '小米', '小芳'}

isdisjoint：判断两个集合是否不包含相同的元素，如果不包含相同元素则返回 True，否则返回 False。

a_set = {'小米', '小兵', '小芳'}
b_set = {'小芳', '小花', '小王'}
print(a_set.isdisjoint(b_set))
# False

数据类型转换

字符串与数字

字符串转为数字，需要字符串中所有字符都是数字才能转换，空格除外。

new_str = str(123456)
print(new_str)
new_str = str(3.14)
print(new_str)
new_int = int(' 12')
print(new_int)
new_float = float(' 1.2')
print(new_float)
# 123456
# 3.14
# 12
# 1.2

字符串与比特类型

bytes：比特类型，二进制的数据流，是一种特殊的字符串。

bt = b'my name is xiaofang'
print(type(bt))
# <class 'bytes'>

bytes 支持很多字符串的函数，只不过参数如果是字符串则需要传递比特类型。

bt = b'my name is xiaofang'
print(bt.capitalize())
print(bt.replace(b'my', b'your'))
print(bt[0])
print(bt[0:3])
print(bt.find(b'name'))
# b'My name is xiaofang'
# b'your name is xiaofang'
# 109
# b'my '
# 3

encode：将字符串转成比特（bytes）类型。

decode：将字比特（bytes）类型转成字符串。

str_data = 'my name is xiaofang 中文'
byte_data = str_data.encode('utf-8')
print(byte_data)
# b'my name is xiaofang \xe4\xb8\xad\xe6\x96\x87'

str_data = byte_data.decode('utf-8')
print(str_data)
# my name is xiaofang 中文

逻辑语句

对于一件事情的正确与否（真假的判断），判断结果为布尔类型。

if：如果。

elif：否则如果。

else：否则。

and：并且

or：或则。

number = 5
if number > 10:
    print('大于10')
elif 5 < number < 8:
    print('大于5小于8')
elif number == 5:
    print('等于5')
else:
    print('小于5')
# 等于5

循环语句

for in：将列表、元祖、字符串、字典中的每个元素按照顺序进行遍历。

for item in '字符串':
    print(item, end=',')
# 字,符,串,

while：根据条件执行循环体，可以无限循环。

count = 9
while count >= 0:
    print(count, end=',')
    count -= 1
# 9,8,7,6,5,4,3,2,1,0,

continue：跳过当前循环，继续下一次循环。

break：直接结束当前循环。

count = 9
while count >= 0:
    if count == 5:
        continue
    elif count == 2:
        break
    print(count, end=',')
    count -= 1
# 9,8,7,6,

range：返回一个可迭代对象，参数依次为开始（包括，默认0）、结束（不包括）、步长（默认1）。

for item in range(10):
    print(item, end=',')
# 0,1,2,3,4,5,6,7,8,9,

for item in range(10, 20, 2):
    print(item, end=',')
# 10,11,12,13,14,15,16,17,18,19,

函数的定义

Python 中的函数分为内置函数和自定义函数，函数定义使用 def 关键字，使用 return 关键字返回数据。

def 函数名(参数列表...):
    函数体
    return 返回值

函数参数

Python 函数的参数从左到右依次是必传参数、默认（可选）参数、可变元组参数、可变字典参数。

可选参数就是设置了默认值的参数。

可变参数就是没有固定的参数名和数量。

def 函数名(arg1, arg2 = 默认值, *args, **kwargs):
    函数体

*args：将无参数名的值合并成元组。

**kwargs：将有参数名与默认值的赋值语句合并成字典。

def test_args(*args, **kwargs):
    print(args, type(args))
    print(kwargs, type(kwargs))
test_args(1, 2, 3, name='xiaofang', age=12)
test_args(*(1, 2, 3), **{'name': 'xiaofang', 'age': 12})
# (1, 2, 3) <class 'tuple'>
# {'name': 'xiaofang', 'age': 12} <class 'dict'>

函数参数的类型

在 Python3.7 后才可以定义函数参数的类型，并且函数也不会对参数类型进行验证。

def 函数名(arg1: str, arg2: int = 默认值, *args: int, **kwargs: str):
    函数体

全局变量与局部变量

全局变量：在 Python 脚本最上层代码块的变量。可以在函数内被读取使用，但无法修改。

局部变量：在函数体内定义的变量。

global：将全局变量可以在函数体内进行修改。

name = 'xiaofang'
def test():
    global name
    name = 'xiaoming'

递归函数

在函数内，通过返回值，直接执行自身函数。

def 函数名1(arg1):
    return 函数名1(arg1)

lambda匿名函数

f = lambda: 1
print(f())
# 1

f1 = lambda x=1, y=2: x + y
print(f1())
# 3

users = [{'name': 'xiaosan'}, {'name': 'xiaohua'}, {'name': 'xiaosi'}]
users.sort(key=lambda user: user['name'])
print(users)
# [{'name': 'xiaohua'}, {'name': 'xiaosan'}, {'name': 'xiaosi'}]

类

验证下
类变量、实例变量和局部变量。
类方法、静态方法和实例方法。

类的self

self 是类函数中的必传参数，且必须放在第一个参数位置。

self 是一个对象，他代表实例化的变量自身。

self 可以直接通过点来定义一个类变量。

self 中的变量与含有 self 参数的函数可以在类中的任何一个函数内随意调用。

非函数中定义的变量在定义的时候不用 self。

class Person(object):
    name = None
    age = None

    def run(self):
        print(f'{self.name}在奔跑')

    def jump(self):
        print(f'{self.name}在跳跃')
xiaofang = Person()
xiaofang.name = '小芳'
xiaofang.run()
xiaofang.jump()
# 小芳在奔跑
# 小芳在跳跃

类的构造函数

类中的一种默认函数，用来将类实例化的同时，将参数传入类中。

def __init__(self, a, b):
    self.a = a
    self.b = b

setter/getter

使用 property 函数：

class Rect:
    def __init__(self, area):
        self.__area = area
    def get_area(self):
        return self.__area
    def set_area(self, value):
        self.__area = value
    def del_area(self):
        self.__area = 0
    area = property(get_area, set_area, del_area)
rect = Rect(30)
rect.area = 10
print(rect.area)
# 10

del rect.area
print(rect.area)
# 0

使用 @property 属性装饰器：

class Rect:
    def __init__(self, area):
        self.__area = area
    @property
    def area(self):
        return self.__area
    @area.setter
    def area(self, value):
        self.__area = value
    @area.deleter
    def area(self):
        self.__area = 0
rect = Rect(30)
rect.area = 10
print(rect.area)
# 10

del rect.area
print(rect.area)
# 0

封装

Python 类的属性和方法可以添加两个下划线 __ 来设置为私有。

但这种方式只是 Python 的一种“投机取巧”，添加了 __ 的属性和方法，其实在底层修改了名字，在名字前了 _类名 前缀。

Python 内置了很多 类似 __init__ 这样的前后都包含下划线的写法，这是由 Python 解析器调用的，我们不要用这种命名格式。

继承

Python 如果没有显式指定父类，就是默认继承 object 类。

Python 和 C++ 一样，是支持多继承的。如果多个父类中包含同名的类方法，根据子类继承父类的前后次序决定继承哪个父类的方法，即排在前面的父类中的类方法会覆盖排在后面父类中的同名类方法。

class 子类(父类1, 父类2,...):
    pass

重写父类方法

class Bird:
    def isWing(self):
        print("鸟有翅膀")
    def fly(self):
        print("鸟会飞")
class Ostrich(Bird):
    def fly(self):
        print("鸵鸟不会飞")
        super().fly()
ostrich = Ostrich()
ostrich.fly()
# 鸵鸟不会飞
# 鸟会飞

Bird.fly(ostrich)
# 鸟会飞

限制动态添加实例方法

不会对其子类生效。

class 类名:
    __slots__ = ()

动态创建类

使用内置函数 type 不仅仅可以查看某个变量的类型，还可以用于动态创建一个类。

def say(self):
    print("我要学 Python！")
CLanguage = type("CLanguage", (object,), dict(say=say, name="C语言"))
clangs = CLanguage()
clangs.say()
print(clangs.name)
# 我要学 Python！
# C语言