1. 字符串
字符串的输出：
# f-strings
name = "兰克奖"
age = 60
f_string1 = f'奖项：{name}，年龄：{age}'
a = 10
b = 20
f_string2 = f'a + b = {a + b}'字符串遍历：
s = "hello"
for i in s:
print(i)for-else 语句：
"""
格式：
for 变量 in 容器:
重复执行的代码块
else:
如果for循环不是通过break结束的时候，一定会执行的代码块
"""
s = "hello"
for i in s:
if i == "m":
print(1)
break
else:
print(2)字符串切片：
# 截取到最后一个元素
s = "hello"
print(s[1:])
# 从第一个元素开始截取
s = "hello"
print(s[:3])
# 步长
s = "hello python"
print(s[2:10:2])
# 步长（可以为负）
s = "hello python"
print(s[10:2:-2])
# 字符串的反转（逆序）
s = "hello python"
print(s[::-1])字符串方法：
（1）find方法（定位字符串中某字符的位置，找到之后不再继续查找）
注：从第3个字符开始（包含第3），到第15个字符截止（不包含第15）（左闭右开区间）。字符串的字符排序是从"0"开始。如果查找不到结果为"-1"。
h = "thhcieenable"
v1 = h.find('e',3,15)
v2 = h.find('ee')
v3 = h.rfind('e')
print(v1,v2,v3)
# 返回：5 5 6
（2）index方法（查找子序列）（如果查找不到会报错，建议使用find查找）
h = '8rong8chi'
v = h.index('1')
print('v')
# 返回：
Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/python_s3/D1/s1.py", line 103, in <module>
v = h.index('1')
ValueError: substring not found（查找不到程序报错）
（3）count方法（在字符串中寻找子序列的个数）
注：从第4个字符开始（包含第4），到第16个字符截止（不包含第16）（左闭右开区间）。字符串的字符排序是从"0"开始。
h = 'bokeyuanbokeyuan'
v = h.count('an',4,16)
print(v)
# 返回：2
（4）partition、rpartition、split、rsplit方法（分割）
注：sep=''换行后第二行第一个字符前不出现空格。
h = 'abcacd'
v1 = h.partition('c')
v2 = h.rpartition('c')
v3 = h.split('c')
v4 = h.rsplit('c')
print(v1,'\n',v2,'\n',v3,'\n',v4,sep='')
# 返回：
('ab', 'c', 'acd')
('abca', 'c', 'd')
['ab', 'a', 'd']
['ab', 'a', 'd']
（5）isalpha方法（判断字符串是否只是字母或汉字）
h = '马云mayun'
v = h.isalpha()
print(v)
# 返回：True
（6）isdecimal、isdigit、isnumeric方法（判断字符串是否只含数字（特殊写法的数字））
h1 = '1'
h2 = '1②'
h3 = '1②三'
v1 = h1.isdecimal()
v2 = h1.isdigit()
v3 = h1.isnumeric()
v4 = h2.isdecimal()
v5 = h2.isdigit()
v6 = h2.isnumeric()
v7 = h3.isdecimal()
v8 = h3.isdigit()
v9 = h3.isnumeric()
print(v1,v2,v3,v4,v5,v6,v7,v8,v9)
# 返回：True True True False True True False False True
（7）islower和isupper方法（判断是否至少有一个英文字符且字符串中的英文字符是否全为小写字母或全为大写字母）
h = 'ab'
v1 = h.islower()
v2 = h.isupper()
print(v1,v2)
# 返回：True False
（8）startswith与endswith方法（判断字符串是否以某个子序列开头或结尾）
h = '打麻将'
v1 = h.startswith('打')
v2 = h.endswith('不')
print(v1,v2)
# 返回：True False
（9）replace方法（将字符串中的内容替换，可以设置替换的个数）
h = 'thhhhhang'
v = h.replace('h','t',3)
print(v)
# 返回：tttthhang
（10）upper方法（将字符串中所有字母变大写）
h = "thhcieenable"
v = h.upper()
print(v)
# 返回：THHCIEENABLE
（11）lower方法（将字符串中所有字母变小写）
h = 'DouDiZhu'
v = h.lower()
print(v)
# 返回：doudizhu
（12）strip、lstrip、rstrip方法（从左和从右、从左、从右删除指定的字符串）
注：按顺序删除，不能跳过字符顺序（建议多尝试几个其他的字符串找规律）。
h = '中华人民共和国美利坚合众国'
v1 = h.strip('中里利人民国众合利')
v2 = h.lstrip('中里利人民国众合利')
v3 = h.rstrip('中里利人民国众合利')
print(v1,'\n',v2, '\n',v3)
# 返回：
华人民共和国美利坚
华人民共和国美利坚合众国
中华人民共和国美利坚
（13）ljust和rjust方法（将字符串设定为指定的长度，并额外添加设定的字符）
h = 'th'
v1 = h.ljust(6,'*')
v2 = h.rjust(6,'#')
# v3 = h.ljust(6)
print(v1,'\n',v2)
# 返回：
th****
####th
（14）center方法（设置字符串宽度为30，并将字符串居中，'华'作为填充）
注：只能是一个字符，大于一个字符会报错。
h = 'doudizhu'
v = h.center(30,'华')
print(v)
# 返回：华华华华华华华华华华华doudizhu华华华华华华华华华华华
（15）join方法（将字符串中的每个字符按照指定分隔符进行拼接）
h = '天王盖地虎'
print(h)
v = '1'.join(h)
print(v)
# 返回：
天王盖地虎
天1王1盖1地1虎
（16）capitlize方法（将字符串首字母改为大写）
h = 'doudizhu'
v = h.capitalize()
print(v)
# 返回：Doudizhu
（17）casefold方法（将字符串中所有字母变小写）（推荐）
h = 'DouDiZhu'
v = h.casefold()
print(v)
# 返回：doudizhu
（18）format方法（格式化，将字符串中的占位符替代为指定的值）（两种写法）
h = 'i am a {s},my name is {n}'
v = h.format(s = 'boy',n = 'th')
print(v)
j = 'i am a {0},my name is {1}'
u = j.format('girl','xx')
print(u)
# 返回：
i am a boy,my name is th
i am a girl,my name is xx
（19）format_map方法（格式化）
h = 'i am a {s},my name is {n}'
v = h.format_map({'s':'boy','n':'th'})
print(v)
# 返回：i am a boy,my name is th
（20）isalnum方法（判断字符串中是否只包含字母和数字）
h = '123abc_'
v = h.isalnum()
print(v)
# 返回：False
（21）expandtabs方法（断句功能）
注：\t为制表符，\n为换行符。
s = 'QQ\tpassword\n123456\t654321\n908\tth\n507\tqwert\n888\tuser\n'
v = s.expandtabs(30)
print(v)
# 返回：
QQ password
123456 654321
908 th
507 qwert
888 user
（22）isprintable方法（判断字符串中是否存在不可显示的字符，如空格，制表符，换行符）
h = 'th\tmy\n'
v = h.isprintable()
print(v)
# 返回：False
（23）isspace方法（判断字符串是否全部是空格（制表符，换行符））
h = ' \t \n'
v = h.isspace()
print(v)
# 返回：True
（24）title和istitle方法（将字符串变为标题和判断字符串是否为标题）
h1 = 'Process finished with exit code 0'
h2 = h1.title()
v1 = h1.istitle()
v2 = h2.istitle()
print(h2,'\n',v1,'\n',v2)
# 返回：
Process Finished With Exit Code 0
False
True
（25）zfill方法（设置字符串长度并用'0'填充剩余长度不足部分）
h = 'th'
v = h.zfill(6)
print(v)
# 返回：0000th
（26）maketrans和translate方法（制定转译规则和进行转译操作）
注：sep=''换行后第二行第一个字符前不出现空格。
h = '天王盖地虎，宝塔镇河妖'
m = str.maketrans('宝塔镇河妖','小鸡炖蘑菇')
v = h.translate(m)
print(h,'\n',v,sep='')
# 返回：
天王盖地虎，宝塔镇河妖
天王盖地虎，小鸡炖蘑菇
（27）splitlines方法（通过换行符分割）
注：True保留换行符，False不保留。sep=''换行后第二行第一个字符前不出现空格。
h = 'qwer\nasdf\nzxcv\n'
v1 = h.splitlines(True)
v2 = h.splitlines(False)
print(v1,'\n',v2,sep='')
# 返回：
['qwer\n', 'asdf\n', 'zxcv\n']
['qwer', 'asdf', 'zxcv']
（28）swapcase方法（大写转换为小写，小写转换为大写）
h = 'TanHang'
v = h.swapcase()
print(v)
# 返回：tANhANG
（29）isidentifier方法（判断字符串是否可为合法的标识符）
h = '_aaq'
v = h.isidentifier()
print(v)
# 返回：True
（30）len方法（显示字符串的长度）
v = len('asdasdasd')
print(v)
# 返回：9
（31）range方法（返回一个可迭代的对象）
注：range（0,100,1）起始值， 结束值，步长。
a = range(0,10,1)
print(a)
for v in a:
print(v)
# 返回：
range(0, 10)
0
1
2
3
4
5
6
7
8
9
（32）字符串的格式化
h1 = 'i am %s,my job is %s.'%('th','teacher')
#打印字符串
h2 = 'percent %.2f'% 99.66
#打印浮点数
h3 = 'i am %(name)s age %(age)d'%{'name':'th','age':20}
#字典
h4 = "i am %(pp).2f %%" % {"pp": 88.99, }
#百分数
txt = 'i am \033[42;1m%(name)s\033[0m'%{'name':'th',}
#改颜色：\033[42;1m%(name)s\033[0m
#将'th'改成绿色
print('root','密码','QQ',sep=':')
#用':'分隔
h5 = 'i want to {2},time {1}, people {0}'.format(3,'today','eat')
#format格式化
h6 = 'i want to {thing},time {time}, people {number}'.format(thing = 'eat',time = 'today', number = 3)
#format格式化
h7 = 'i want to {thing},time {time}, people {number}'.format(**{'thing': 'eat', 'time': 'today', 'number': 3})
#用字典表示
h8 = 'i want to {:s},time {:s}, people {:d}'.format(*['eat', 'today', 3])
#用列表表示
（33）字符串编码
str1 = 'hello马云'
print(str1.encode('utf-8')) #默认utf-8编码
data = str1.encode('utf-8')
print(data.decode('gbk',ignore)) #默认utf-8编码,ignore忽视错误
# 返回：
b'hello\xe9\xa9\xac\xe4\xba\x91'
hello椹浜2. 列表
定义：
存储多个元素，元素可以是任何类型的。
列表方法：
（1）append方法（追加）
li = [1,2,3,'4','5']
li.append('th')
print(li)
# 返回：[1, 2, 3, '4', '5', 'th']
（2）clear方法（清空列表）
li = [1,2,3,'4','5']
li.clear()
print(li)
# 返回：[]
（3）copy方法（拷贝）
li = [1,2,3,'4','5']
v = li.copy()
print(v)
# 返回：[1, 2, 3, '4', '5']
（4）count方法（计算元素出现的次数）
li = [1,2,33,33,'4','5']
v = li.count(33)
print(v)
# 返回：2
（5）extend方法（扩展原列表）
注：参数是可迭代对象。
li = [11, 22, 33, 22, 44]
li.extend(['abc',123])
print(li)
li.extend("hello")
print(li)
# 返回：
[11, 22, 33, 22, 44, 'abc', 123]
[11, 22, 33, 22, 44, 'abc', 123, 'h', 'e', 'l', 'l', 'o']
（6）index方法（根据值获取当前值索引位置）
注：从左至右
li = [11, 22, 33, 22, 44]
v1 = li.index(22)
v2 = li.index(22, 2, 4)
print(v1, v2)
# 返回：1 3
（7）insert方法（在指定索引位置插入元素）
li = [11, 22, 33, 22, 44]
li.insert(3,31)
print(li)
# 返回：[11, 22, 33, 31, 22, 44]
（8）pop方法（删除某个值，并获取删除的值）
注：默认删除最后一个。
li = [11, 22, 33, 22, 44]
v = li.pop(1)
print(v,'\n',li,sep='')
# 返回：
22
[11, 33, 22, 44]
（9）remove方法（删除列表中的指定值，左边优先）
li = [11, 22, 33, 22, 44]
li.remove(22)
print(li)
# 返回：[11, 33, 22, 44]
（10）reverse方法（将当前列表翻转）
li = [11, 22, 33, 22, 44]
li.reverse()
print(li)
# 返回：[44, 22, 33, 22, 11]
（11）sort方法（列表排序）
li = [11, 22, 33, 22, 44]
li.sort()
print(li)
# 返回：[11, 22, 22, 33, 44]
（12）in操作（判断元素是否在列表中）
li = [1, 12, 9, "age", ["刘漂亮", ["19", 10], "庞麦郎"], "alex", True]
v1 = "刘漂亮" in li
v2 = 'age' in li
print(v1,v2)
# 返回：False True
（13）从列表中取元素
li = [1, 12, 9, "age", ["刘漂亮", ["19", 10], "庞麦郎"], "alex", True]
v = li[4][1][0]
print(v)
# 返回：19
（14）del（删除列表里的元素）
li = ['12','zg','gy','th',3]
del li[0:2]
print(li)
# 返回：['gy', 'th', 3]3. 元组
定义：
tuple1 = (1,)
tuple2 = (1,2,3)什么时候使用元组存储一组数据？
当那组数据不允许被修改时！
元组方法：
（1）将元组转换为字符串
tu = (3333,8888,6666,['bc'],'q')
s = ''
for i in tu:
s += str(i)
print(s)
# 返回：333388886666['bc']q
（2）count方法（计算元素出现的次数）
tu = (3333,8888,6666,['bc'],'q')
v = tu.count(3333)
print(v)
# 返回：1
（3）index方法（索引）
tu = (333,888,666,['bc'],'q')
v = tu.index(666)
print(v)
# 返回：2
（4）元组的一级元素不支持修改、添加、删除操作
tu = (333, 888, 666, [('bc', 123), 3], 'q')
tu[3][0][1] = 12
print(tu)
# 返回：TypeError: 'tuple' object does not support item assignment
tu = (333, 888, 666, [('bc', 123), 3], 'q')
tu[3][1] = 12
print(tu)
# 返回：(333, 888, 666, [('bc', 123), 12], 'q')4. 字典
特点：
（1）存储的数据是一对一对的
（2）必须通过键得到值（key，value）
（3）键是唯一的，不能重复
格式：
字典名 = {key 1:value 1，key 2:value 2，……，key n:value n}
增删改查：
增：字典名[新的key] = 值
删：字典名.pop(已经存在的key)
删除最后一个键值对：字典名.popitem()
清空键值对：字典名.clear()
改：字典名[已经存在的key] = 新的值
查：字典名.[已经存在的key]，字典名.[key]
遍历字典：
# 方式一
dict = {'name':'张三',
'age':18,
'id':1}
key_list = dict.keys()
for key in key_list:
value = dict.get(key)
print(f"{key}={value}")
# 方式二
dict = {'name':'张三',
'age':18,
'id':1}
item_list = dict.items()
for key,value in item_list:
print(f"{key}={value}")名片管理案例：
# 创建
card_list = []
while True:
ctrl = input("是否开始添加:")
if ctrl == "yes":
card = {
"company": "",
"name": "",
"tel": ""
}
company = input("公司:")
name = input("姓名:")
tel = input("电话:")
for i in card:
card["company"]=company
card["name"]=name
card["tel"]=tel
card_list.append(card)
print(card_list)
else:
break
# 显示
card_list = [{'company': '阿里巴巴', 'name': '马云', 'tel': '18888888888'}, {'company': '深信服', 'name': '何朝曦', 'tel': '16666666666'}]
for i in card_list:
company = i.get("company")
name = i.get("name")
tel = i.get("tel")
print("-"*20)
print("公司:" + company + "\n" + "姓名:" + name + "\n" + "电话:" + tel)
print("-"*20)字典方法：
（1）for循环
注：info.keys生成 key，info.values生成 value，info.items生成键值对。
info = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11,22),
}
],
"k4": (11,22,33,44)
}
for item1 in info.keys():
print(item1)
print('\n')
for item2 in info.values():
print(item2)
print('\n')
for item3 in info.items():
print(item3)
# 返回：
k2
k1
k4
k3
True
18
(11, 22, 33, 44)
[11, [], (), 22, 33, {'kk3': (11, 22), 'kk1': 'vv1', 'kk2': 'vv2'}]
('k2', True)
('k1', 18)
('k4', (11, 22, 33, 44))
('k3', [11, [], (), 22, 33, {'kk3': (11, 22), 'kk1': 'vv1', 'kk2': 'vv2'}])
（2）fromkeys方法（根据序列创建字典，并指定统一的 value）
v = dict.fromkeys(['th',123],999)
print(v)
# 返回：{123: 999, 'th': 999}
（3）get方法（根据 key获取值，若 key不存在，获取到指定的值，默认为 None）
info = {
"k1": 18,
"k2": True,
"k3": [
11,
[],
(),
22,
33,
{
'kk1': 'vv1',
'kk2': 'vv2',
'kk3': (11, 22),
}
],
"k4": (11, 22, 33, 44)
}
v1 = info.get('k33333', 3)
v2 = info.get('k3', 333333)
print(v1, '\n', v2)
# 返回：
3
[11, [], (), 22, 33, {'kk3': (11, 22), 'kk1': 'vv1', 'kk2': 'vv2'}]
（4）pop和popitem方法（删除并获取值）
注：popitem随机删除一个键值对。
dic = {
'k1': 13,
'k2': 45,
'j3': 66
}
v1 = dic.pop('k1')
print(dic, v1)
k2, v2 = dic.popitem()
print(dic, k2, v2)
# 返回：
{'k2': 45, 'j3': 66} 13
{'j3': 66} k2 45
（5）setdefault方法（设置值）
注：若 key已存在，则不设置 value，获取原来的 value；若 key不存在，则添加新设置的键值对，获取新的 value。
dic1 = {
'k1': 13,
'k2': 45,
'k3': 66
}
dic2 = {
'k1': 13,
'k2': 45,
'k3': 66
}
v1 = dic1.setdefault('k1', 123)
v2 = dic2.setdefault('j3', 33)
print(dic1, v1)
print(dic2, v2)
# 返回：
{'k2': 45, 'k1': 13, 'k3': 66} 13
{'j3': 33, 'k2': 45, 'k1': 13, 'k3': 66} 33
（6）update方法（更新值）
注：原字典没有的值将添加进去。
dic1 = {
'k1': 13,
'k2': 45,
'k3': 66
}
dic2 = {
'k1': 33,
'k2': 45,
'k3': 66
}
dic1.update({'k1':33,'k2':'88'})
dic2.update(k1 = 44, k2 = 55, k4 =99)
print(dic1,'\n',dic2, sep='')
# 返回：
{'k1': 33, 'k3': 66, 'k2': '88'}
{'k4': 99, 'k1': 44, 'k3': 66, 'k2': 55}运算符：
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
| + | [1, 2] + [3, 4] | [1, 2] + [3, 4] | 合并 | 字符串、列表、元组 |
| * | ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 复制 | 字符串、列表、元组 |
| in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典(判断 KEY 是否在字典中) |
| not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典(判断 KEY 是否不在字典中) |
5. 集合
集合方法：
（1）add方法（添加）
s = {1,3,6,8}
s.add(9)
print(s)
# 返回：{1, 3, 6, 8, 9}
（2）clear方法（清空）
s = {1,3,6,8}
s.clear()
print(s)
# 返回：set()
（3）copy方法（复制）
s = {1,3,6,8}
s1 = s.copy()
print(s1)
# 返回：{8, 1, 3, 6}
（4）pop方法（随机删除）
s = {'th',1,3,6,8,'a','b','c'}
s.pop()
print(s)
# 返回：{3, 'th', 6, 8, 'c', 'b', 'a'}
（5）remove方法（指定删除，元素不存在会报错）
s = {'th',1,3,6,8,'a','b','c'}
s.remove('th')
print(s)
# 返回：{1, 3, 'a', 6, 8, 'b', 'c'}
（6）discard方法（指定删除，元素不存在不会报错）
s = {'a','b','c','d','e',1,2,3}
s.discard('a')
print(s)
# 返回：{1, 2, 3, 'd', 'b', 'c', 'e'}
（7）交集（intersection或"&"）
s1 = {'th',333,666}
s2 = {'th',666}
print(s1.intersection(s2))
print(s1&s2)
# 返回：{'th', 666}
（8）并集（union或"|"）
s1 = {'th',333,666}
s2 = {'th',666}
print(s1.intersection(s2))
print(s1&s2)
# 返回：{'th', 666}
（10）交叉补集（symmetric_difference或"^"）
s1 = {'th',333,666}
s2 = {'th',666,999}
print(s1.symmetric_difference(s2))
print(s1^s2)
# 返回：{999, 333}
（11）求差集之后更新（difference_update）
s1 = {'th',333,666}
s2 = {'th',666,999}
s1.difference_update(s2)
print(s1)
# 返回：{333}
（12）更新集合（update）
s1 = {'th',333,666}
s2 = {'th',666,999}
s1.update(s2)
print(s1)
# 返回：{'th', 999, 666, 333}
s = {'th',333,666}
s.update([999])
print(s)
# 返回：{666, 999, 333, 'th'}
（13）判断两个集合中是否有相同的元素（isdisjoint）
注：无则返回True，有则返回False。
s1 = {'th',333,666}
s2 = {1}
print(s1.isdisjoint(s2))
# 返回：True
（14）判断两个集合的子集或父集关系（issubset）
s1 = {'th',333,666}
s2 = {'th'}
print(s2.issubset(s1))
# 返回：True
s1 = {'th',333,666}
s2 = {'th'}
print(s1.issuperset(s2))
# 返回：True
（15）冻结集合（frozenset）
注：不可变集合。
s = frozenset('hello')
print(s)
# 返回：frozenset({'l', 'o', 'h', 'e'})
（16）update方法
注：插入整个list、tuple、字符串，打碎插入
s = set([1,2,3,4,5])
s.update('hello')
print(s)
# 返回：{1, 2, 3, 4, 5, 'h', 'o', 'l', 'e'}