1、python以及pycharm的安装
2、pycharm 新建项目
3、文件、目录、包的创建和管理
4、pycharm 的基础使用
5、如何运行代码：
6、安装第三方库
第三方库：是别人已经写好的 python 代码
第一种方法：
第二种方法：pycharm ：不要勾选 user‘s site package
第三种方法：库放在国外的服务器上，需要用到国内安装源，python国内源
python国内源：
清华：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
华中理工大学：http://pypi.hustunique.com/
山东理工大学：http://pypi.sdutlinux.org/
豆瓣：http://pypi.douban.com/simple/
1、基本语法
print 输出
python注释: 表示在 python 当中不会运行的文字（不会当成代码）, 是说明下面的代码是什么？
缩进：
数值
字符串
变量
标识符：（凡是我们自己取的名字，都是标识符。）
标识符的命名风格：
?
input 用户输入
算术运算符：
# +
print(5 + 6)
# -
print(7 - 8)
# *
print(2 * 3)
# /
# 只要是进行除法运算，得到的是一个 float
print(4 / 3)
print(4 / 2)
# 除法运算一定要注意，除数不能为 0
# 除数如果为0，就会报错：ZeroDivisionError: division by zero
# 程序报错以后，就无法继续运行
# print(2/0)
# print(‘hello world‘)
# // 得到的是一个整数。 整除
print(4 // 3)
# % 取余数 : 模运算
print(4 % 3)
# ** 幂运算 4的3次方
print(4 ** 3)
赋值运算符
name = ‘yuze‘
age = 18
#涨一岁
age = age + 1
print(age)
#缩写 age += 1 ==> age = age + 1
age += 2
print(age)
age /= 3
print(age)
?
比较运算符: 比较运算得到的结果是一个 bool 值， True 或 False
> 大于
print(5 > 4) # True
< 小于
print(6 < 3) # False
>= 大于等于
print(6 >= 3) # True
<= 小于等于
print(6 <= 3) # False
!= 不等于
print(6 != 3) # True
TODO: == 才是比较运算， 一个 = 是赋值运算
print(6 == 6)
?
逻辑运算 : 可以使用()提高优先级
a = 3 > 4
print(a)
b = 4 != 5
print(b)
# 运算 and
# 每一个都为 True
print(a and b) # False
# 运算 or
# 只要有一个为 True
print(a or b) # True
# 练习
a = True
b = 5 == 4 # False
c = 5 != 3 # True
print(a and b or c) # True
print(a or b and c) # True
# python 的运算有没有优先级，如何设置优先级
# 使用 () 设置优先级
print(((a and b) or c) and b)
# not 取反
print(not(b)) # True
身份运算
成员运算
# in
name = ‘yuz‘
print(‘u‘ in name) # True
print(‘uz‘ in name) # True
print(‘uai‘ in name) # False
# TODO: in 一定是连着的， yz 是一个整体
print(‘yz‘ in name) # False
print(‘Y‘ in name) # False
随机生成 0-1 之间的浮点数：random.random()
随机生成 0-100 之间的浮点数：random.randint(1, 100)
import random
f_num = random.random()
print(f_num)
num = random.randint(0, 100)
print(num)
本节问题：
问题一：python中如何表示字母，比如要将一个人的名字储存下来？
问题二：字符串如何定义?
问题三：字符串如果要换行怎么办？
问题四：数值类型的数据可以转换成字符串吗？
问题五：可以把两个字符串组成一个吗？
问题六；如何获取字符串中某个具体的字符？
单引号、双引号：定义单行字符串
三引号、三双引号： 多行字符串定义
空字符串： s=‘‘
str():
注意点：字符串中有单引号时，外面用双引号注意区分
"""字符串的定义
如何表示字符串：
- 引号表示字符串
- 单引号 ‘‘
- 双引号 ""
- 三引号 ‘‘‘ ‘‘‘
- 三双引号 """ """
"""
name1 = "yuze"
print(name1)
name2 = ‘yuze‘
print(name2)
name3 = ‘‘‘yuze‘‘‘
print(name3)
name4 = """yuze"""
print(name4)
print(name1 == name2 == name3 == name4) # True
print(name1 == name2) # True
print(name1 == name3) # True
print(name1 == name4) # True
?
1、下标索引取值
name = ‘yuzwang‘
print(name[1]) # u
print(name[0]) # y
# 获取第3个字符
print(name[2]) # z
# 获取 g
print(name[6])
print(name[-1])
?
2、切片： [:][::]
"""字符串的切片 slice
获取多个字符
索引获取的公式：
m_str[start:end:step]
注意：end - start 的符号 必须和 step 的符号相同才可以获取到索引
step 的值不能为0
"""
name = ‘yuzwang‘
# 要 1 和 2
print(name[1:2]) # u
print(name[0:1]) # y
# TODO: 这个才是对的
# TODO: 顾头不顾腚，取头不取尾，取左不取右
print(name[0:2]) # yu
print(name[3:6]) # wan
# 什么是 step , 取完第一个索引，把索引 + 多少
# step = 2
print(name[3:6:2]) # wn
print(name[1:5:3]) # ua
# step 可以为负数
print(name[5:1:-3]) # nz
print(name[5:1:3]) # 取不到值 None
print(name[1:4:-2]) # 取不到值 None
# TODO: end - start 的符号 必须和 step 的符号相同才可以获取到索引
# TODO:step 的值不能为0，否则会报错：ValueError: slice step cannot be zero
print(name[1:5:0])
# TODO: IndexError
print(name[1000000]) # IndexError: string index out of range
print(name[1:1000000]) # uzwang 不会报错，会取到所有值
name = "yuzewang"
# 省略 end ,表示取到最后
print(name[1:])
# 省略 start ，表示从 0 开始
print(name[:5])
# 复制，copy 从头到尾，
# TODO: 面试题：复制字符串
print(name[:])
name_copy = name[:]
print(name_copy)
# 倒序 ‘123456‘ ==> ‘654321‘
# TODO：面试题：倒序一个字符串
print(name[::-1]) # gnawezuy
3、字符串拼接和转义
+ 号：‘hello‘ + ‘python‘
字符串转义：
name = ‘yuz‘
family_name = ‘wang‘
print(name + family_name)
print(name + ‘ ‘ + family_name)
字符串和数字能不能相加
print(‘yuz‘ + 7) # 字符串和数字不能直接相加，会报错：TypeError: must be str, not int
print(‘yuz‘ + str(7)) # yuz7
数据类型的转化
print(int(name)) # 报错：ValueError: invalid literal for int() with base 10: ‘yuz‘
print(int(‘12‘)) # 12
print(bool(34)) # True
bool 转化，只要是非0，非空的就是True
字符串换行
‘\‘ 不会分开成两行
name = "yuze ooasfjojo"
"wefwllfjlj"
print(name) # yuze ooasfjojowefwllfjlj
# 三引号换行，得到多行数据
name = """yuze flaljlkfjlajl
lsajllakj fjk
sjljjfljladf
aljfl
"""
print(name)
# 单引号中 \n 表示换行
name = ‘kaixina lajj\nlfljajljssfjdlk\njljajs‘
print(name)
name = "qin er cai"
# 字符串拼接
print(name + ‘wang‘)
# 使用 join 拼接
print(name.join([‘a‘,‘b‘,‘c‘])) # aqin er caibqin er caic
# 时间 [‘2020‘, ‘08‘, ‘03‘] 用 / 连接起来
print(‘/‘.join([‘2020‘, ‘08‘, ‘03‘])) # 2020/08/03
print(‘2020‘ + ‘/‘ + ‘08‘ + ‘/‘ + ‘03‘) # 2020/08/03
# find：在字符串当中查找某个字符或者字符串的位置
# 会得到索引
a = "wangyuze is coming"
print(a.find(‘e‘)) # 7
index = a.find(‘e‘)
print(index) # 7
# 如果找的有两个呢？ i，会得到第一个
print(a.find(‘i‘)) # 9
# 如果是一个子串呢？ ng
print(a.find(‘ng‘)) # 2
# 如果找不到怎么办？会得到 -1 ，这是规定
print(a.find(‘isnot‘)) # -1
# 如果子串不在一起，也是找不到，返回 -1
print(a.find(‘wn‘)) # -1
# index 约等于 find
# 区别：index 找不到元素的时候，会报错，find 找不到的时候返回-1
print(a.index(‘ng‘)) # 2
print(a.index(‘wn‘)) # ValueError: substring not found
# count 统计某个字符出现的次数
m_str = ‘foweofpweef‘
print(m_str.count(‘o‘)) # 2
song = "我爱你，我喜欢你，我..."
print(song.count(‘我‘)) # 3
?
# replace 替换
song = "我爱你，我喜欢你，我..."
print(song.replace(‘你‘, ‘ta‘)) # 我爱ta，我喜欢ta，我...
?
# split 切分、切割 ==》 和 join 相反
time_string = ‘2020/08/03‘
print(time_string.split(‘/‘)) # [‘2020‘, ‘08‘, ‘03‘]
?
format : 格式化输出
upper : 将字母大写
# upper 所有字母都大写
name = ‘yuze‘
print(name.upper()) # YUZE
?
# lower 所有字母都小写
name = ‘JECK‘
print(name.lower()) # jeck
# strip 去掉两边的特殊字符，如果什么都不传，就是去掉空格或者换行符
name = ‘ yuze wang ‘
print(name.strip()) # yuze wang
print(name)
cp = "&雨泽&哈哈&"
print(cp.strip(‘&‘)) # 雨泽&哈哈
# len 计算字符串的长度
name = ‘yuzewang ‘
print(len(name)) # 9
?
format 格式化输出
| 数据 | 格式 | 结果 | 描述 |
|---|---|---|---|
| 5.11111 | {:.2f} | 5.11 | 保留小数点后两位 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| aa | {:<10} | aa | 左对齐（宽度为10） |
| aa | {:^10} | aa | 中间对齐（宽度为10） |
?```
# 现在需要打印下面的格式：
-------------------
借条
借款人：yuz
债权人：double king
金额：500
-------------------
loan_name = ‘yuz‘
rich_man = ‘double king‘
money = 500
# # 方法一：
# print("---------------------")
# print(‘借条‘)
# print(‘借款人：‘ + loan_name)
# print(‘债权人：‘ + rich_man)
# print(‘金额：‘ + str(money))
# print(‘---------------------‘)
#
#
# 方法二：
# {} 表示占坑符，占位符
# 位置一定要匹配，不能乱填顺序
# print("""
# -------------------
# 借条
# 借款人：{}
# 债权人：{}
# 金额：{:.2f} 万
# -------------------
# """.format(loan_name, rich_man, money))
#
#
# # 方法三：
# # f-string : python3.6 以后才支持
# print(f"""
# -------------------
# 借条
# 借款人：{loan_name}
# 债权人：{rich_man}
# 金额：{money} 万
# -------------------
# """)
传统的格式化输出 %
| 符号 | 描述 |
|---|---|
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %f | 格式化浮点数字，可指定小数点后的精度 |
列表的定义
列表的常见操作
下标取值（索引取值）：获取某一个元素
切片操作：获取多个元素
修改元素的值：可以通过下标修改指定位置的元素。
# 5 个人，5个大佬 ， 使用列表
big_boss = [‘Demons‘, ‘Go‘, ‘EE‘, ‘上善若水‘, ‘summer‘]
print(big_boss)
# 元素可以是任意的数据类型
big_boss = [‘Demons‘, 11, True, 33.33, ‘summer‘]
print(big_boss)
big_boss = [‘Demons‘, 11, True, 33.33, [‘a‘,‘b‘,‘c‘]]
print(big_boss)
big_boss = [‘Demons‘, 11, True, 33.33, [‘a‘,‘b‘,[‘yuz‘,True]]]
print(big_boss)
# 索引： 获取索引为 0 的元素
print(big_boss[0]) # Demons
print(big_boss[-1]) # [‘a‘, ‘b‘, [‘yuz‘, True]]
print(big_boss[-2]) # 33.33
print(big_boss[2]) # True
# 获取 a
print(big_boss[-1][0]) # a
last_one = big_boss[-1]
print(last_one[0]) # a
# 获取 ‘yuz‘
print(big_boss[-1][-1][0]) # yuz
# 切片
print(big_boss[:3]) # [‘Demons‘, 11, True]
列表嵌套
列表中如果有多层嵌套，取值时需要一层一层的取值
lst = [
‘a‘,
‘b‘,
[1,2,3]
]
print(lst[0]) # a
print(lst[-1][1]) # 2
?
列表的方法
| 方法 | 描述 |
|---|---|
| append | 在列表的尾部加入一个元素 |
| insert | 在指定位置插入一个元素 |
| extend | 插入多个元素 |
| pop | 删除一个元素（默认从列表尾部删除，也可以指定下标进行删除） |
| remove | 删除指定的元素（从前往后找） |
| index | 查找元素的位置，找到第一个就返回结果 |
| count | 统计元素的个数 |
| sort | 将列表的元素进行排序 |
| reverse | 将列表内元素反序（头变为尾，尾变头） |
# TODO：坑
dalaos = [‘随风‘]
new_dalao = dalaos.append(‘利己‘)
print(dalaos) # [‘随风‘, ‘利己‘]
# append() 返回 None
print(new_dalao) # None
# 再添加多个，[‘一罐‘,‘本本‘,‘可爱‘,‘美雪‘] 添加到最后
dalaos.extend([‘一罐‘,‘本本‘,‘可爱‘,‘美雪‘])
print(dalaos)
# TODO: 坑2 报错：AttributeError: ‘NoneType‘ object has no attribute ‘append‘
new_dalao = dalaos.append(‘sfo‘).append(‘hello‘).append(‘sof‘)
print(new_dalao)
# 增加某个元素，修改的是原来的变量 lst
lst = [‘yuz‘, ‘shanshan‘, ‘rita‘]
lst.append(‘裴纶‘)
print(lst) # [‘yuz‘, ‘shanshan‘, ‘rita‘, ‘裴纶‘]
# insert 指定索引位置添加元素，不是获取索引，不用[]
lst.insert(1, ‘仙人球‘)
print(lst) # [‘yuz‘, ‘仙人球‘, ‘shanshan‘, ‘rita‘, ‘裴纶‘]
# extend 添加多个，可以合并 2 个列表
lst.extend([‘tiger‘, ‘f2‘])
print(lst) # [‘yuz‘, ‘仙人球‘, ‘shanshan‘, ‘rita‘, ‘裴纶‘, ‘tiger‘, ‘f2‘]
lst = [1,2,3]
lst.append(3)
print(f"第一次尝试{lst}") # 第一次尝试[1, 2, 3, 3]
# lst.extend(3)
# print(f"第二次尝试{lst}") # 报错：TypeError: ‘int‘ object is not iterable
lst.extend([3])
print(f"第三次尝试{lst}") # 第三次尝试[1, 2, 3, 3, 3]
a = [1,2,3]
b = [4,5,6]
# b 是作为一个整体，一个元素，添加到 a 当中
# a.append(b)
# print(a) # [1, 2, 3, [4, 5, 6]]
# b 是拆开里面元素，作为多个元素，添加到 a 当中
a.extend(b)
print(a) # [1, 2, 3, 4, 5, 6]
"""列表的删除
- remove
- delete
- pop
"""
# remove: 在列表当中删除指定的值
big_boss = [‘糖‘, ‘木易‘, ‘均价‘]
big_boss.remove(‘木易‘)
print(big_boss) # [‘糖‘, ‘均价‘]
# delete 异类：尽量不要用
# del big_boss[0]
# print(big_boss) # [‘均价‘]
# pop 0 代表索引为 0
big_boss.pop(0)
print(big_boss) # [‘均价‘]
# 获取索引为 0 的值
print(big_boss[0])
big_boss.append(‘木易‘)
print(big_boss) # [‘均价‘, ‘木易‘]
"""列表的修改
lst[0] = 1
"""
lst = [1,2,3]
lst[1] = ‘a‘
print(lst) # [1, ‘a‘, 3]
lst[1],lst[2] = ‘c‘, ‘d‘
print(lst) # [1, ‘c‘, ‘d‘]
lst[1:] = 5,6
print(lst) # [1, 5, 6]
"""列表的方法
- index
- count
- sort
- reverse
- clear
"""
lst = [4,5,6,5]
# # 统计
# print(lst.count(5)) # 2
#
# # index 查找得到第一次出现的索引值
# print(lst.index(5)) # 1
#
# # sort 排序
# print(lst.sort()) # None
#
# lst.sort()
# print(lst) # [4, 5, 5, 6]
#
#
# # reverse 反向，倒序 , 相当于 [::-1]
# lst.reverse()
# print(lst) # [6, 5, 5, 4]
# 反向排序
lst.sort(reverse=True)
print(lst) # [6, 5, 5, 4]
# clera 清除一个列表
lst.clear()
print(lst) # []
?
元组的定义：
元组的常见操作
注意点
元组的方法
tuple_yuz = (‘yuz‘,‘一罐‘,[‘闲人‘,‘七七‘,‘小骄傲‘])
# 修改的是元组的元素，元组的元素是列表
# tuple_yuz[2] = [‘新列表‘]
# print(tuple_yuz) # 不能修改元组的元素
# 为什么这里可以改??
# 元组的不可变是相对的，不是说里面所有的内容都完全不能变
# 只要看索引的前面是不是一个可变的类型
tuple_yuz[2][0] = [‘新列表‘]
print(tuple_yuz)
tuple_yuz = (‘yuz‘,‘一罐‘,{‘tuple‘:‘yuze‘})
# 索引前面是元组，代表我们要修改的是元组的元素，不可以
# tuple_yuz[2] = ‘hello world‘
# tuple_yuz[2] 是字典，可变类型，可以直接修改
tuple_yuz[2][‘name‘] = ‘hello world‘
print(tuple_yuz)
# 索引前yuz是列表，可以改变
yuz = [‘yuz‘,‘一罐‘,(‘四叶草‘,‘晓峰‘)]
yuz[2] = ‘hello‘
print(yuz)
# yuz[2]是元组，不可变
yuz[2][1] = ‘youxi‘
tuple_demo = ()
print(tuple_demo)
# TODO:坑 ，一个元素的元组表示，不是一个元组，而是去掉括号后的原始数据类型
# tuple_demo_2 = (1)
# print(tuple_demo_2)
# 如果想表示一个元素的元组，记得务必在元素后面加一个逗号
# tuple_demo_3 = (1,)
# print(len(tuple_demo_3))
tuple_demo_4 = (1,3,4,5,5,)
print(len(tuple_demo_4))
tuple_demo_5 = 1
print(tuple_demo_5)
# 元组解包
family_name,name = (‘wang‘,‘yuze‘)
# family_name,name = (‘wang‘,‘yuze‘,‘hello‘) # 值要一一对应，否则会报错
print(family_name)
print(name)
a,b = 3,4
print(a)
print(b)
family_name,name,*other = (‘wang‘,‘yuze‘,‘hello‘,‘world‘)
print(family_name)
print(name)
print(*other)
?
字典的定义：
也是用来存储多个数据的
字典：字典用 {} 来标识
字典能够表示元素更具体的意思，每个元素表示的意义是什么，可以通过 key 命名
字典的结构：就是将它看做是一个 {key:value} 键:值 对的集合，键必须是唯一的（在一个字典中）
空字典 ： {}
字典定义的方式：
# 方式一：
dic = {‘name‘:‘musen‘, ‘age‘:18}
# 方式二：
dic = {name = ‘musen‘, age = 18}
注意点：
字典的增删改查
增
通过指定键去添加相应的值
dic[key] = value
update() : 将一个字典的所有元素更新到另一个字典中
# 简单理解
dic.update({‘a‘:1, ‘b‘:2})
改：通过指定键去修改对应的值
dic[key] = value
删
pop() : 删除指定的键，删除的键不存在会报错（避免错误可以添加默认值）
dic.pop(key)
popitem() : 删除一个键值对，删除最后一个添加的元素
关键字 del : 通过键删除
del dic[key]
查
# 列表：当每个元素有具体的意义，你又想去单独获取的时候，可读性不强
beisheng = [‘星际穿越‘, ‘蜘蛛侠‘, ‘上海堡垒‘, ‘分手大师‘, ‘前任3‘]
print(beisheng[2])
# 字典：key: 元素的名称， value: 元素的值 ， 键值对：成对
# 用 {} 在最外面
# key: value, key1: value1
beisheng = {‘favor‘:‘星际穿越‘,‘hate‘:‘蜘蛛侠‘,‘first‘:‘上海堡垒‘,‘last‘:‘分手大师‘,‘twice‘:‘前任3‘}
print(beisheng[‘hate‘]) # 蜘蛛侠
# 重名的key
beisheng = {‘favor‘:‘星际穿越‘,
‘hate‘:‘蜘蛛侠‘,
‘first‘:‘上海堡垒‘,
‘favor‘:‘分手大师‘,
‘twice‘:‘前任3‘}
# favor 后面的值会覆盖前面的值
print(beisheng[‘favor‘]) # 分手大师
print(beisheng) # {‘favor‘: ‘分手大师‘, ‘hate‘: ‘蜘蛛侠‘, ‘first‘: ‘上海堡垒‘, ‘twice‘: ‘前任3‘}
# key 不能是列表
# beisheng = {‘favor‘:‘星际穿越‘,
# [‘hate‘]:‘蜘蛛侠‘,
# ‘first‘:‘上海堡垒‘,
# ‘favor‘:‘分手大师‘,
# ‘twice‘:‘前任3‘}
# print(beisheng) # 报错：TypeError: unhashable type: ‘list‘
# 键为数字: 没有意义，不建议使用
beisheng = {1:‘星际穿越‘,
3:‘蜘蛛侠‘,
2:‘上海堡垒‘,
5:‘分手大师‘,
4:‘前任3‘}
print(beisheng) # {1: ‘星际穿越‘, 3: ‘蜘蛛侠‘, 2: ‘上海堡垒‘, 5: ‘分手大师‘, 4: ‘前任3‘}
beisheng = {‘favor‘:‘星际穿越‘,
‘hate‘:‘蜘蛛侠‘,
‘first‘:‘上海堡垒‘,
‘last‘:‘分手大师‘,
‘twice‘:‘前任3‘}
# 获取，查
print(beisheng[‘hate‘])
# 字典没有索引和切片
# 修改
beisheng[‘hate‘] = ‘蝙蝠侠‘
print(beisheng) # {‘favor‘: ‘星际穿越‘, ‘hate‘: ‘蝙蝠侠‘, ‘first‘: ‘上海堡垒‘, ‘last‘: ‘分手大师‘, ‘twice‘: ‘前任3‘}
# 添加, 和修改是一样的
# 什么时候是修改，什么时候又是添加？
# 看 key：当 key 已经存在的时候，是修改，当之前没有这个key，就是添加。
beisheng[‘scared‘] = ‘贞子‘
print(beisheng)
beisheng[‘scared‘] = ‘午夜凶铃‘
print(beisheng)
?
定义：
注意：
集合的方法：
集合的重要应用场景：去重
集合的交集、并集、差集
# 集合不是键值对
# 集合是无序的
# 不能通过索引获取
# 重复的元素直接丢掉，集合目前我们使用的最多的功能就是去重
set_yuz = {‘yuz‘,‘鲁西西‘,‘闲人‘,‘yiguan‘}
print(set_yuz)
# print(set_yuz[1]) # 会报错
print(len(set_yuz))
# 去重
set_yuz = list(set([‘yuz‘,‘鲁西西‘,‘闲人‘,‘yuz‘]))
print(set_yuz)
# split 分割
# a = ‘hello world‘
# b = a.split(‘w‘)
# print(b)
a = ‘hello/world/sofo/sooof‘
b = a.split(‘/‘,1) # 数字1代表分割一次
print(a) # a 是字符串，不会变
print(b)
字符串转换成列表
s = ‘1ab1cd‘
print(list(s)) # [‘1‘, ‘a‘, ‘b‘, ‘1‘, ‘c‘, ‘d‘]
print(s.split(‘1‘)) # [‘‘, ‘ab‘, ‘cd‘]
?
字符串转换成元组
s = ‘1ab1cd‘
print(tuple(s)) # (‘1‘, ‘a‘, ‘b‘, ‘1‘, ‘c‘, ‘d‘)
?
字符串转换成字典
a=‘1ab1cd‘
b=‘123456‘
print(zip(a,b)) # <zip object at 0x00000000022952C8>
print(dict(zip(a,b))) # {‘1‘: ‘4‘, ‘a‘: ‘2‘, ‘b‘: ‘3‘, ‘c‘: ‘5‘, ‘d‘: ‘6‘}
a=‘1ab1cdd4e5‘
b=‘123456‘
print(zip(a,b)) # <zip object at 0x00000000022952C8>
print(dict(zip(a,b))) # {‘1‘: ‘4‘, ‘a‘: ‘2‘, ‘b‘: ‘3‘, ‘c‘: ‘5‘, ‘d‘: ‘6‘}
?
字符串转换成集合
a=‘1ab1cd1d‘
print(set(a)) # {‘1‘, ‘a‘, ‘c‘, ‘b‘, ‘d‘}
?
列表转换成字符串
list = ["3","d","aaa"]
print("".join(list)) # 3daaa
print(" ".join(list)) # 3 d aaa
print("!".join(list)) # 3!d!aaa
?
列表转换成元组
list = [‘1‘,‘2‘,‘3‘,‘a‘,(1,2,3),1,[1,2],{"a":1}]
print(tuple(list)) # (‘1‘, ‘2‘, ‘3‘, ‘a‘, (1, 2, 3), 1, [1, 2], {‘a‘: 1})
?
列表转换成字典
list1 = [‘1‘,‘2‘,‘3‘,‘4‘,‘a‘,(1,2,3),5,6]
list2 = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,[1,2],{"g":"h"}]
dict1 = dict(zip(list1,list2))
print(dict1)
# {‘1‘: ‘a‘, ‘2‘: ‘b‘, ‘3‘: ‘c‘, ‘4‘: ‘d‘, ‘a‘: ‘e‘, (1, 2, 3): ‘f‘, 5: [1, 2], 6: {‘g‘: ‘h‘}}
?
列表转换成集合
list = [‘1‘,‘2‘,‘3‘,‘3‘]
print(set(list)) #{‘3‘, ‘1‘, ‘2‘}
元组转换成字符串
tuple = (‘1‘,‘2‘,‘3‘,‘4‘,‘2‘,‘a‘)
print(‘‘.join(tuple)) # 12342a
元组转换成列表
tuple = (1,2,3,4,5,‘2‘,‘a‘)
print(list(tuple)) # [1, 2, 3, 4, 5, ‘2‘, ‘a‘]
元组转换成字典
tuple1 = (‘1‘, ‘2‘, ‘3‘, ‘4‘,111,(11,22,33),"")
tuple2 = (‘a‘, ‘b‘, ‘c‘, ‘d‘,‘e‘,‘f‘,‘h‘,‘g‘,‘i‘,‘j‘,‘k‘)
dict1 = dict(zip(tuple1, tuple2))
print(dict1) # {‘1‘: ‘a‘, ‘2‘: ‘b‘, ‘3‘: ‘c‘, ‘4‘: ‘d‘, 111: ‘e‘, (11, 22, 33): ‘f‘, ‘‘: ‘h‘}
元组转换成集合
tuple1 = (‘1‘,‘2‘,‘3‘,‘4‘,4,‘4‘,4,1)
print(set(tuple1)) # {1, 4, ‘3‘, ‘1‘, ‘2‘, ‘4‘}
字典转换成字符串
dict1 = {1:‘a‘,2:‘b‘,3:‘c‘}
list1 = list(dict1.values())
print("".join(list1)) # abc
tuple1 = tuple(dict1.values())
print("".join(tuple1)) # abc
字典转换成列表/元组/集合
dict1 = {1:‘a‘,2:‘b‘,3:‘c‘}
print(list(dict1.keys())) # [1, 2, 3]
print(list(dict1.values())) # [‘a‘, ‘b‘, ‘c‘]
print(tuple(dict1.keys())) # (1, 2, 3)
print(tuple(dict1.values())) # (‘a‘, ‘b‘, ‘c‘)
print(set(dict1.keys())) # {1, 2, 3}
print(set(dict1.values())) # {‘a‘, ‘b‘, ‘c‘}
print(tuple(dict1.items())) #生成元祖为单位的元祖
# ((1, ‘a‘), (2, ‘b‘), (3, ‘c‘))
print(list(dict1.items())) #生成元祖为单位的列表
# [(1, ‘a‘), (2, ‘b‘), (3, ‘c‘)]
print(set(dict1.items())) #生成元祖为单位的集合
# {(2, ‘b‘), (3, ‘c‘), (1, ‘a‘)}
集合转换成字符串
set1 = {"1","2","ac"}
print("".join(set1)) # 2ac1
print(type("".join(set1))) # <class ‘str‘>
集合转换成列表/元组
set1 = {1,2,3,4,5,6}
print(list(set1)) # [1, 2, 3, 4, 5, 6]
print(tuple(set1)) # (1, 2, 3, 4, 5, 6)
集合转换成字典
set1 = {1,2,3,4,5,6}
set2 = {‘a‘,‘b‘,‘c‘,‘d‘}
print(dict(zip(set1,set2)))
# {1: ‘d‘, 2: ‘a‘, 3: ‘b‘, 4: ‘c‘}
?
if条件判断
# if的写法（else可以省略）
if (条件表达式):
pass
else:
pass
if (条件表达式):
pass
elif (条件表达式):
pass
else:
pass
# 例如：
username = "yuze"
if username == "yuze" or username == "yuzewang":
#缩进表示条件满足以后需要执行的子代码，是一个分支
print("登录成功")
elif username == ""
print("请输入用户名")
elif username == "Demo"
print("没有该用户")
else
print("登录失败")
if语句用于验证某个条件
使用if需要注意的点
循环控制流
while循环作用：用来重复执行某个操作
while 语法
while 判断条件：
执行代码
# 例如：
times = 0
while times < 999:
print("我说了{times}次")
times = times + 1
continue: 表示手工进入下一个循环体，进入下次循环
break：表示手工强制退出整个while循环
作用：
语法
for 迭代变量 in 字符串|列表|元组|字典|集合：
代码块
# 例如：
add = "http://c.biancheng.net/python/"
#for循环，遍历 add 字符串
for ch in add:
print(ch,end="")
continue：手工进入下一个循环体，进入下次循环
break：手工强制退出整个while循环
break
continue
常用在循环结构中
在循环中遇到continue,就跳出本次循环，继续下一次循环
for i,value in enumerate(list):
print(i, value)
for k,v in mdict.items():
print(k, v)
for value in mdict.values():
print(value)
for key in mdict.keys():
print(key)
for k in mdict:
print(k)
range() 函数
for i in range(100):
print(i)
函数的概念：以数学函数来理解
作用：传入一个自变量，会得到一个另外的变量，这个变量会根据自变量变化而变化
用于存储一段代码。 是封装
定义函数关键字：def
为什么要写函数：方便好用、复用性高
函数名：属于标识符，遵循标识符的命名规则：
语法：
def 函数名(参数):
函数内部功能代码一
函数内部功能代码二
函数内部功能代码三
函数内部功能代码四
def add(a,b):
print(a+b)
函数中的代码如何运行？
不要在一个文件中定义两个同名函数，后面的会覆盖前面的
def add (a,b):
print(a+b)
def add (a,b):
print(a-b)
add(1,2) # -1
2、函数的调用
使用函数的过程叫做调用函数；调用的时候会给变量赋值，即变量 = 值
调用方法：
函数名()
函数的相互调用
1、参数的定义
2、形参与实参
def add (a,b):
print(a+b)
return(a+b)
add(1,2) # a,b是形参， 1,2 是实参
位置参数
def add (a,b):
print(a+b)
return(a+b)
add(1,2) # 1对应a， 2对应b
关键字参数
def add (a,b):
print(a+b)
return(a+b)
add(b=3,a=2)
默认参数
def add (a,b=8):
print(a+b)
return(a+b)
不定长参数
def add (a,*b):
print(a)
print(b)
add(1,2,3,4) # 1,(2,3,4)
def add (a,*b):
print(a)
print(b)
add(1,2,3,4,c=1) #报错：默认参数要放到位置参数后面，不定长参数放到位置参数后面
**只能收集关键字参数
**kwargs 存放很多关键字参数
将数据转换为字典的形式
def add (a,**b):
print(a)
print(b)
add(1,c=1,d=2) # 1 {‘c‘: 1, ‘d‘: 2}
不定长参数的作用
拆包：
def marry(male,female):
print(male)
print(female)
couple = ("老王","小星星")
marry(*couple)
couple = {"male":"小王","female":"老刘"}
marry(**couple)
?
print ：输出
input ：输入
type ：查看数据类型
range ：生成数据
id ：获取数据内存地址
int、float、str、bool、list、dict、tuple、set ：代表对应的数据类型，转换数据类型
max ：获取最大的值，可以传多个参数，可以传列表
min ：获取最小的值，可以传多个参数，可以传列表
sum ：求和
enumetate:
# enumerate() 将列表中的元素及其位置转换为成对的元组
m_list = [‘aa‘, ‘bb‘, ‘cc‘, ‘dd‘]
print(list(enumerate(m_list)))
# [(0, ‘aa‘), (1, ‘bb‘), (2, ‘cc‘), (3, ‘dd‘)]
print(list(enumerate(m_list, start = 1)))
# [(1, ‘aa‘), (2, ‘bb‘), (3, ‘cc‘), (4, ‘dd‘)]
eval ：可以去掉一个字符串的引号
m_str = "6>7"
print(m_str)
print(eval(m_str)) # False
m_str = ‘{"username":"yuz","age":18}‘
print(m_str) # {"username":"yuz","age":18}
print(type(m_str)) # <class ‘str‘>
print(eval(m_str)) # {‘username‘: ‘yuz‘, ‘age‘: 18}
print(type(eval(m_str))) # <class ‘dict‘>
filter ：过滤某些数据 filter（调用函数，列表）
li = [2,3,4,5,6,7]
def get_odd(value):
if value % 2 == 0:
return True
return False
res = filter(get_odd, li)
print(list(res)) # [2, 4, 6]
li = [2,3,4,5,6,7]
def square(value):
return value ** 2
res = map(square, li)
print(list(res)) # [4, 9, 16, 25, 36, 49]
li_1 = ["yuz","hello","world"]
li_2 = [43,12,15]
print(list(zip(li1,li2))) # [(‘yuz‘, 43), (‘hello‘, 12), (‘world‘, 15)]
a = zip(li1, li2)
print(dict(a)) # {‘yuz‘: 43, ‘hello‘: 12, ‘world‘: 15}
（六）、模块和包
模块
包
模块导入
是模块间变量和函数的互相使用 ，需要使用 import 的关键字
import ... 后面只能跟 模块，不能跟函数，变量
from .. import ... 后面可以跟模块，函数，类，变量
导入自己的模块，别人的第三方模块，一般使用from import ,不用import..
google内部约定，导入模块只导入模块这一层，然后使用 模块名.函数名() 来调用函数
from class_9_file import demo01
demo01.test01_fun()
import .. 调用函数的时候需要些很长的前缀，比较麻烦
不建议使用：from... import *
as 重命名 - 避免同名函数冲突
导入时导入到模块这一层，使用时使用模块名.函数名
使用别名
from class_9_file import demo01 as d
d.test01_fun()
不要用相对导入，要绝对导入，就是从根目录开始导入
打开文件，使用内置函数 open()
特别注意：打开文件不管进行什么操作后，一定要关闭文件，否则会出现数据不对，或者写入内容不生效，文件无法再次被打开等情况
f = open("python32.txt")
f.close()
为了避免忘记关闭文件，可以使用with语句，操作完成后会自动关闭文件
with open(‘python32.txt‘,‘r‘,encoding=‘utf8‘) as f:
print(f.read())
with open(‘python32.txt‘,‘a‘,encoding=‘utf8‘) as f:
print(f.write())
不在同一路径下要用绝对路径，windows要加 r 防止转义，有反斜杠，mac不用加
with open(r‘J:\学习资料\Study\PythonAndSelenium\柠檬班python自动化课程\python32_API\class_09_file\python32.txt‘) as f:
print(f.readline())
?
mode 打开方式
read() 读取
with open("python32.txt", mode = ‘r‘, encoding = ‘utf8‘) as f:
print(f.read())
with open(‘1.png‘, mode= ‘rb‘) as f:
print(f.read())
readline() 读取一行
with open(‘python32.txt‘, encoding = ‘utf8‘) as f:
print(f.readline())
?
readlines() 读取所有行，会以列表的形式展示
with open(‘log.txt‘, encoding = ‘utf8‘) as f:
print(f.readlines()) # 可以显示换行符
?
mode 写入方式
with open(‘python32.txt‘, mode = ‘w‘, encoding = ‘utf8‘) as f:
f.write(‘裴纶‘)
with open(‘python32.txt‘, mode = ‘a‘, encoding = ‘utf8‘) as f:
f.write(‘哈哈哈‘)
sys . path 包含项目开始根目录路径和 python 内置的目录路径
os 是 python 内置的模块需要用 import 导入： import os
找模块
python中一般不直接写入绝对路径， 而是通过代码获取
获取当前文件的路径：
abs_path = os.path.abspath(_file_)
_file_ 表示运行的文件的名称
获取当前文件的目录路径: 两种写法，用第一种绝对路径
dir_name = os.path.dirname(abs_name)
dir_name = os.path.dirname(_file_)
获取不与当前文件同一个目录下的文件路径
比如，获取pac01 下面的 demo.txt:
txt_file_path = os.path.join(dirname, ‘pac01‘, ‘demo.txt‘)
读取图片文件（二进制格式）
dir_name = os.path.dirname(os.path.abspath(file))
png_pic = os.path.join(dir_name,‘1.png‘)
f = open(png_pic,mode=‘rb‘)
print(f.read())
f.close()
os.path.abspath() 获取绝对路径
os.path.dirname() 获取文件/目录所在路径
os.path.join(a, b) 连接两个部分的路径，组成一个完整路径
os.getcwd() 获取当前工作路径
os.chdir() 切换工作路径
os.mkdir() 在某个目录下创建一个新目录
os.rmdir() 删除一个目录
os.listdir() 获取当前路径下的目录，返回列表格式数据
os.path.isdir() 判断当前文件是否是目录，返回布尔值
os.path.isfile() 判断当前文件是否是文件，返回布尔值
语法一：try...except....
程序先执行try中的代码，一旦try中某个代码报错， 会直接跳到except，try剩下的代码不会执行
try:
要执行的可能发生异常的代码
except:
程序发生异常后，你希望程序做的事情
try:
1/0
except IndexError as e:
print(e)
# 其中as e可以在后面用来展示异常信息，但不能展示异常类型
语法二：try...except....finally
try:
1/0
except ZeroDivisionError as e:
print("不能除以0")
finally:
print("无论异常与否，都会继续执行的代码")
# 运行结果：
# 不能除以0
# 无论异常与否，都会继续执行的代码
try...except...else
try:
1 / 0
print("正常执行的代码")
except ZeroDivisionError as e:
print("不能除以0")
else:
print("代码没有报错才会执行")
print("正常执行的代码的后面部分")
# 运行结果：
# 不能除以0
方式一：
try:
{‘name‘:‘yez‘}[‘age‘]
a = 1/0
lst = [‘yz‘,‘yr‘]
lst[3]
except(ZeroDivisionError, IndexError, KeyError) as err:
print(err)
print(‘hello‘)
except ImportError as e:
print()
方式二：
try:
{‘name‘:‘yez‘}[‘age‘]
a = 1/0
lst = [‘yz‘,‘yr‘]
lst[3]
except ZeroDivisionError as err:
print(err)
except IndexError as err:
print(‘index error‘)
except KeyError:
print(‘key error‘)
raise 主动抛出异常
def adult_add(a, b):
# 两个数相加， a, b 一定要大于18， 否则就不能运行
if (a < 18) or (b < 18):
raise ValueError(‘参数必须大于18‘)
c = a + b
return c
print(adult_add(3, 4))
print(‘函数执行完成。‘) # 上面一行报错，这行不会打
try:
adult_add(3, 4)
except:
print(‘函数执行完成。‘) # 结果会打印：函数执行完成。
断言: assert
断言的作用：判断真假
断言的时候，如果断言成功，程序继续执行
如果断言失败，程序终止运行，本质上断言失败会触发一个异常类型：AssertionError
断言，主要用在预期结果和实际结果的比对
height = int(input(‘输入身高：‘))
print(height > 180) # False
assert height > 180
print("断言有结果")
什么是类：
类的表示：（下面三种写法作用完全一样）
class 类名称:
# 类当中的内容
属性 ==》 特征
行为
class 类名称():
pass
class 类名称(object):
pass
class Dog:
# 类内容
tailed = True
def say(self):
print(‘汪汪。。。‘)
类的命名
使用 类 的好处
什么是对象：
class Dog:
# 类内容
tailed = True
def say(self):
print(‘汪汪。。。‘)
zhonghua = Dog()
print(zhonghua) # 是对象 <__main__.Dog object at 0x00000000022724A8>
print(Dog) # 是类 <class ‘__main__.Dog‘>
# Dog 不加括号的时候是类
zhonghua = Dog
print(zhonghua) # <class ‘__main__.Dog‘>
?
类方法：每一个成员或者整个类都能调用的行为
实例方法、对象方法：只能是需要一个单独的成员调用的行为，不能是整个类调用
class Dog:
# 有尾巴
# 类属性
tailed = True
# 实例方法
def say(self):
print(‘汪汪汪。。。‘)
# 对象
teddy = Dog()
# 类属性的获取
print(Dog.tailed) # True
# 对象获取属性
print(teddy.tailed) # True
# 属性可以后天修改
Dog.tailed = False
print(Dog.tailed) # False
print(teddy.tailed) # False
teddy.tailed = ‘有时候有尾巴，有时候没有‘
print(Dog.tailed) # False
print(teddy.tailed) # 有时候有尾巴，有时候没有
# 类方法的调用
# Dog.say() # 会报错
# Dog.say(‘abc‘) # 不要用整个类去调用实例方法
# teddy.say(‘abc‘) # 会报错
teddy.say() # 汪汪汪。。。
一个对象：除了整个类都具备的属性，还有自己的特征。 对象自己的特征就叫实例属性或者对象属性。
每个对象都有自己不同的实例属性，可以在对象生成的时候传入实际参数，这个实际参数就是实例属性，传入实际参数时需要有对应的形式参数，这些形式参数不能在类后面直接定义，这里就定义了一个特别函数，方法，_init_，在这里面定义好的形式参数，最终在对象初始化的时候传入实际参数，这个实例属性产生的过程就叫对象的初始化。
传入的实际参数是在什么时候调用的？？？
teddy = Dog(name = ‘teddy‘, color = ‘blue‘) 自动调用 _init_
不需要写 Dog._init_()
TODO: 一定不要写成 _int_
class Dog:
tailed = True
# 定义一个特别函数，方法，定义好的形式参数，最终在对象初始化的时候传入实际参数
def __init__(self, name, color):
"""初始化函数，初始化方法"""
# 自定义对象产生的过程
# 实例属性的产生 self.name 定义一个叫做 name 的实例属性
self.name = name
self.color = color
def say(self):
print(‘汪汪汪。。。‘)
teddy = Dog(name = ‘teddy‘, color = ‘blue‘)
teddy.say()
# 获取实例属性
print(teddy.color)
# 类不能调用实例属性
# print(Dog.color) # AttributeError: type object ‘Dog‘ has no attribute ‘color‘
?
实例化
通过一个类去创建一个对象，就是实例化。
实例化是产生对象的过程
实例化就是函数的调用
产生对象，实例化对象的时候，会自动调用 _init_ 这个方法
self.name = name
self.name ==> 实例属性
name ====> 参数， teddy 值。
name 这个name是变量，和类和对象没有关系
什么是 self ：
所谓的self，可以理解为自己，就是我们的实例本身，代表实例对象，谁去调用代表谁。
Kitty 这个实例对象调用，self就代表Kitty
jingel 这个实例对象去调用，self就代表jingel
某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给 self，只需要传递后面的参数即可
self 可以改成其他名字，但不建议改，你改了别人就不知道具体的含义了
class Dog:
tailed = True
# 定义一个特别函数，方法，定义好的形式参数，最终在对象初始化的时候传入实际参数
def __init__(self, name, color=‘grey‘):
"""初始化函数，初始化方法"""
# 自定义对象产生的过程
# 实例属性的产生 self.name 定义一个叫做 name 的实例属性
# dog.name = name # 不能这样写，函数里面不能使用全局变量，这个时候 dog 这个对象还没有产生出来
# Dog.name = name # 也不能这么写，不能所有的狗都叫同一个名字
self.name = name
self.color = color
print(self)
def say(self):
print(‘汪汪汪。。。‘)
dog = Dog(‘teddy‘)
print(dog.color) # grey
# dog
print(dog) # self 和 dog 对象是同一个地址
# ha = Dog(‘teddy‘)
# print(ha.color) # grey
# # dog
# print(ha) # self 和 ha 对象是同一个地址
?
定义：
使用装饰器 @classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）
调用：
应用场景：
类方法调用
定义：
调用：
应用场景：
静态方法调用：
静态方法存在的理由：
def say_static(times): # 放在这里是普通的函数，和放在类里面效果是一样的，只是调用时这个直接调用，调用类里面的需要加前缀
print(f‘汪汪。。。{times} 声‘)
class Dog:
tailed = True
# 定义一个特别函数，方法，定义好的形式参数，最终在对象初始化的时候传入实际参数
def __init__(self, name, color=‘grey‘):
"""初始化函数，初始化方法"""
self.name = name
self.color = color
print(self)
# 实例方法
def say(self, times):
print(f‘{self}汪汪汪。。。{times} 声‘)
# 静态方法
@staticmethod
def say_static(times):
print(f‘汪汪汪。。。{times} 声‘)
# # 类方法。进化
# def jinhua(self):
# print(‘狗类正在进化‘)
# Dog.tailed = False
# 声明：这是一个类方法
# 固定写法
@classmethod
def jinhua(cls):
print(‘狗类正在进化‘)
Dog.tailed = False
haha = Dog(‘haha‘)
yiyi = Dog(‘yiyi‘)
# print(haha.tailed) # F
# print(yiyi.tailed) # F
# Dog.jinhua() # jinhua()是实例方法，不能使用类去调用
# print(haha.tailed)
# print(yiyi.tailed)
# 类方法的调用
# Dog.jinhua() # Dog 加括号表示对象，不加括号表示类
# haha.tailed
# haha.jinhua()
# print(haha.tailed)
#
# haha.say(5)
# 静态方法的调用，类和对象，都可以调用静态方法
haha.say_static(5)
Dog.say_static(6)
# 普通函数版
say_static(7)
定义类两种方式的区别：
# Python2 中称为经典类，在python3 中默认继承 object
class MyTest:
pass
# python2 中称为新式类。
class MyTest(object):
pass
# 注意点：python3 中上面两种定义方法没有区别，都是继承 object 这个父类
在python3 的继承中，所有的类都默认继承自 object 这个基类。
子类通过继承可以获得父类的属性和方法。
被继承的类叫父类（也叫基类），继承的类叫子类
注意：私有属性不能继承
作用：
# 普通写法定义手机类和智能手机类
class Mobile:
def __init__(self, model, color=‘blacd‘):
self.model = model
self.color = color
def call(self):
"""打电话"""
print(f"{self} 手机正在打电话。")
class SmartPhone:
def __init__(self, model, color=‘blacd‘):
self.model = model
self.color = color
def call(self):
"""打电话"""
print(f"{self} 手机正在打电话。")
def play_game(self):
print("玩游戏")
# 使用继承
class Mobile():
def __init__(self, brand, model, color=‘blacd‘):
self.model = model
self.color = color
self.brand = brand
def call(self):
"""打电话"""
print(f"{self} 手机正在打电话。")
class SmartPhone(Mobile):
def play_game(self):
print("玩游戏")
# iphone = SmartPhone()
# iphone.play_game() # 这里会报错，初始化的时候需要调用__init__方法，自己没有去找父类，父类的__init__需要传参数
iphone = SmartPhone(‘iphone12‘, ‘apple‘)
iphone.play_game()
?
重写父类方法
调用重名的父类方法
class Mobile():
def __init__(self, brand, model, color=‘blacd‘):
self.model = model
self.color = color
self.brand = brand
def call(self):
"""打电话"""
print(f"{self} 手机正在打电话。")
class SmartPhone(Mobile):
def __init__(self, model, brand, color=‘red‘, pixel = 2000):
# self.model = model
# self.color = color
# self.brand = brand # 这三行代码父类中有，可以使用 super()
super().__init__(brand, model, color) # 使用 super() 直接调用父类的方法
self.fiveG = True
self.pixel = pixel
def play_game(self):
print("玩游戏")
def call(self):
"""智能手机打电话"""
print(‘开视频‘)
super().call()
# super 函数的使用
smart = SmartPhone(‘p40‘,‘huawei‘)
print(smart.pixel)
smart.call()
获取对象属性的时候，如果对象中没有这个属性，代码就会报错
可以使用 getattr( 对象, 属性名称 , 默认值) 动态获取属性，并在属性后面传入一个默认值，如果对象没有这个属性就会显示默认值，代码就不会报错
还可以动态修改属性，使用 setattr( 对象, 属性名称 , 属性值)
class Mobile:
def __init__(self, brand, model):
# 先天初始化过程中形成的属性
self.brand = brand
self.model = model
def call(self):
print(‘正在打电话。。‘)
iphone = Mobile(‘apple‘, ‘xr‘)
# 获取属性
# print(iphone.brand)
# 修改属性
# iphone.brand = ‘aple‘
# 定义新的实例属性
# 后天养成的特性
# iphone.video = ‘美颜‘
# print(iphone.video)
# 获取一个不存在的属性
# 如果获取不存在的属性，代码会报错
# print(iphone.games) # AttributeError: ‘Mobile‘ object has no attribute ‘games‘
# 动态获取属性
# getattr 内置函数
# print(getattr(iphone, ‘games‘)) # 还是报错：AttributeError: ‘Mobile‘ object has no attribute ‘games‘
# default ，如果获取不到属性名，传入 default 默认值，就不会报错了
# getattr 不会修改原来的对象的属性
print(getattr(iphone, ‘games‘, ‘吃鸡‘))
# print(iphone.games,) # 还是会报错，因为iphone 没有games属性
# 动态修改属性
setattr(iphone, ‘games‘, ‘王者荣耀‘)
print(iphone.games) # 王者荣耀
原文：https://www.cnblogs.com/duncan1863/p/13585368.html