Day5 字典、元组、集合、字符串

Day5

重点

字典的键是唯一的，同一个字典的同一个键，只能出现一次

字典.setdefault(键，值) - 键不存在会添加，存在则不会修改

\t 水平制表符 相当于一个tab键

\n、\r 换行

a. del 字典[键] - 删除字典指定键对应的键值对

b. 字典.pop(键) - 取走字典指定键对应值

1.字典

1.列表和字典的选择

如果需要同时保存多个意义相同的数据使用列表；

如果同时保存多个意义不同的数据就使用字典。

# 定义一个变量保存学生的信息
stu = ['小明', '男', 18, 97, 40, 67]
print(stu[0])  # 用列表定义的话，不清楚所提取的数据的含义

# 用字典来定义    用键来说明意义
stu = {'name': '小明', 'gender': '男', 'age': 18, 'height': 97, '体重': 40, 'score': 67}
print(stu['name'])
print(stu['score'])

2.什么是字典(dict)

1.字典是容器型数据类型；将{}作为容器的标志，里面多个键值对（元素）用逗号隔开：

​ {键1:值1,键2:值2,键3:值3,…}

2.字典是可变的(支持增删改)；字典是无序的(顺序不影响结果，不支持下标操作)

3.字典的元素：

​ a. 元素必须是键值对

​ b. 键必须是不可变的类型的数据（字符串、数字、布尔、元组等，一般使用字符串作为键）键是唯一的，同一个字典同一个键只能出现一次

​ c. 值可以是任何类型的数据

1）空字典

d1 = {}

2）字典是无序的

print({'a':10,'b':20} == {'b':20,'a':10})			#True

3) 字典的键必须是不可变类型的数据

d2 = {'a':10,20:30,1.2:40,(10,20):50}

4）键是唯一的

d3 = {'a': 10,'a': 100,'b': 20}
print(d3)					#{'a': 100,'b': 20}

5）值可以是任何类型的数据

stu = {'name': '小明', 'gender': '男', 'age': 18, 'height': 97, '体重': 40, 'score': 67}
class1 = {
    'name': 'python2301',
    'teacher':{'name': '余婷','age':18,'tel':'136782301'},
    'student':[
        {'name':'小明','age':28,'school':'清华大学','专业':'计算机'},
        {'name':'小张','age':21,'school':'清华大学','专业':'计算机'},
        {'name':'小王','age':29,'school':'北京大学','专业':'数学'}
    ]
}               #class这个字典中含有三个键值对

3.字典的增删改查

1） 查 - 获取字典的值

a.查单个 - 获取某个值

​ 语法：字典[键] - 获取字典中指定键对应的值

dog = {'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
print(dog['name'])
print(dog['breed'])
#print(dog['weight'])    #KeyError: 'weight'

class1 = {
    'name': 'python2301',
    'teacher': {'name': '余婷', 'age': 18, 'tel': '13678192302'},
    'students': [
        {'name': 'stu1', 'age': 19, 'school': '清华大学', '专业': '经济', 'contact': {'name': '张三', 'tel': '110'}},
        {'name': 'stu2', 'age': 28, 'school': '北京大学', '专业': '大数据', 'contact': {'name': '李四', 'tel': '192'}},
        {'name': 'stu3', 'age': 22, 'school': '厦门大学', '专业': '计算机', 'contact': {'name': '王五', 'tel': '920'}},
        {'name': 'stu4', 'age': 17, 'school': '南京大学', '专业': '物联网', 'contact': {'name': '赵六', 'tel': '2833'}},
    ]
}  # class这个字典中含有三个键值对

# 1.获取班级名称
print(class1['name'])
# 2,获取讲师的名字
t = class1['teacher']
print(t['name'])
# 3.获取所有学生的名字和对应的学校
for stu in class1['students']:
    print(stu['name'],stu['school'])
# 4.获取未成年学生的名
for stu in class1['students']:
    if stu['age']<18:
        print(stu['name'])
# 5.获取第一个学生的联系人电话
st = class1['students'][0]
print(st['contact']['tel'])

b.字典.get(键)

字典.get(键) - 获取字典中指定键对应的值，如果不存在返回None

字典.get(键,默认值) - 获取字典中指定键对应的值

dog = {'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
print(dog.get('age'))#3
print(dog.get('age',1))#3
print(dog.get('weight', '56斤'))#weight键不存在，则输出默认值56斤

2） 字典的遍历

​ for 变量 in 字典:

​ 循环体(变量依次获取到的是字典的键)

dog = {'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
for x in dog:
    print('key:',x,'value:', dog[x])

3） 增 改

a.字典[键] = 值

• 当键存在就修改这个键对应的值，当键不存在的时候就添加键值对

dog = {'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
dog['name'] = '猜猜'
print(dog)  # {'name': '猜猜', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
dog['gender'] = '母狗'
print(dog)  # {'name': '猜猜', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10, 'gender': '母狗'}

b.字典.setdefault(键,值)

• 添加键值对（键不存在就添加，存在就不会修改）

dog = {'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
dog.setdefault('name','大黄')
dog.setdefault('gender','公狗')
print(dog)#{'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10, 'gender': '公狗'}
#对已经有的键值对，setdefault不能进行修改，没有的键值对，可以添加

# 给所有没有折扣的商品添加discount的值为1
goods_list = [
    {'id': 'g001', 'price': 89, 'count': 100},
    {'id': 'g001', 'price': 207, 'count': 50, 'discount': 0.9},
    {'id': 'g001', 'price': 102, 'count': 33},
    {'id': 'g001', 'price': 25, 'count': 897, 'discount': 0.88}
]
for x in goods_list:
    x.setdefault('discount', 1)
print(goods_list)

c.改 - 修改键对应的值

字典[键] = 值 - 如果键存在就修改指定键对应的值

dog = {'name': '财财', 'age': 3, 'color': '黄色', 'breed': '土狗'}
print(dog)
dog['name'] = '来钱儿'
print(dog)

4） 删 - 删除键值对

a. del 字典[键] - 删除字典指定键对应的键值对

b. 字典.pop(键) - 取走字典指定键对应值

dog = {'name': '旺财', 'age': 3, 'breed': '土狗', 'color': '黄色', 'price': 10}
print(dog)

del dog['breed']
print(dog)  # {'name': '旺财', 'age': 3, 'color': '黄色', 'price': 10}

result = dog.pop('color')
print(dog, result)  # {'name': '旺财', 'age': 3, 'price': 10} 黄色

4.字典的相关操作

字典不支持加法运算、乘法运算和比较大小

1）in和not in

键 in 字典 - 字典中是否存在指定的键对应的键值对

d1 = {'a': 10, 'b': 20, 'c': 30}
print(10 in d1)  # False
print('a' in d1)  # True

2）相关函数

1. len(字典)

获取字典的长度

print(len(dict1))

2. dict(数据)

将指定的数据转换成字典

对数据的要求：

a.数据必须是一个序列

b.序列中的每个元素必须是有且只有两个元素的小序列

data1 = [[10, 20], [20, 30], ['a', 'b']]
print(dict(data1))  # {10: 20, 20: 30, 'a': 'b'}
print(dict(['ab', 'cd', '12']))  # {'a': 'b', 'c': 'd', '1': '2'}
print(dict(['ab', [10, 20], range(2)]))  # 'a': 'b', 10: 20, 0: 1}
print(dict(name='jack')) # {'name': 'jack'}

3. list(字典)

• 将字典转换成列表的时候，是将字典中所有的键作为列表的元素

dict1 = {'a': 10, 'b': 20, 'c': 30}
print(list(dict1))  # ['a', 'b', 'c']

3）相关方法

1）字典.clear() - 清空字典

2）字典.copy()

复制字典产生一个一模一样的新字典并返回

3）其他方法

字典.keys() - 获取字典所有的键，返回一个序列

字典.values() - 获取字典所有的值，返回一个序列

字典.items() - 将字典转成一个序列，序列中的元素是每个键值对应的元组

dict1 = {'a': 10, 'b': 20, 'c': 30}
print(dict1.keys())  # dict_keys(['a', 'b', 'c'])
print(dict1.values())  # dict_values([10, 20, 30])
print(dict1.items())  # dict_items([('a', 10), ('b', 20), ('c', 30)])

4）字典1 .update(字典2)

将字典2中所有的键值对都添加到字典1中

dict1 = {'a': 10, 'b': 20, 'c': 30}
dict1.update({100: 200, 200: 300, 'a': 100})
print(dict1)

2.元组

1.什么是元组(tuple)

1)元组是容器型数据类型；将()作为容器的标志，里面多个元素用逗号隔开：（数据1，数据2，数据3，…）
2)元组是不可变的(不支持增删改查)；元组是有序的(顺序影响结果；支持下标操作)
3)任何类型的数据店都可以作为元组中的元素

2.元组的语法

1)空元组

t1 = ()
print(t1)

2)只有一个元素的元组

必须在唯一的元素后加逗号：(元素,)

t2 = (100)
print(t2, type(t2))  # 100 <class 'int'>
t3 = (100,)
print(t3, type(t3))  # (100,) <class 'tuple'>

3)正常的元组

t4 = (10, 20, 'abc', 30)
print(t4)

4)在没有歧义的情况下，元组的()可以省略

直接将多个数据用逗号隔开，也是一个元组

t5 = 100, 200, 300, 400
print(t5)

3.元组的使用

使用元组的实际情况：一般不会主动使用元组保存多个数据；但是遇到元组的时候必须会使用元组

1)元组是不可变的列表

列表相关操作和应用中，除了可变相关内容，其他元组都支持

a.获取元组

列表怎么获取元素，元组就可以怎么获取

print(t6[3], t6[-1])
print(t6[1:-1])
print(t6[0::2])
for index in range(len(t6)):
    print(index, t6[index])
for index, item in enumerate(t6):
    print(index, item)

b.加、乘、比较大小、in和not in

t1 = (10, 20, 30)
t2 = (100, 200)
print(t1 + t2)  # (10, 20, 30, 100, 200)
print(t1 * 2)  # (10, 20, 30, 10, 20, 30)
print(t1 > t2)  # False
print(10 in t1)  # True

c.相关函数：

sum、max、min、sorted、len、tuple(比如将字典里的键获取后变成元组)

d.相关方法：

元组.count(元素)、元组.index(元素)

2.获取元组和列表元素的另一种方式(了解)

让变量的个数和列表或者元组中的元素的个数保持一致，来依次获取列表或者元组中的元素

list1 = [100, 200, 300]
x, y, z = list1
print(x, y, z)

t1 = (10, 20)
m, n = t1
print(m, n)
print('-----------------------------')

# [(0,100),(1,200),(2,300)]
# x=(0,100)
# x=(1,200)
# index,item=(0,100)
for x in enumerate(list1):
    print(x)

list2 = [('小花', 18, '女'), ('小明', 20, '男'), ('张三', 30, '男')]
for name, age, gender in list2:
    print(name, age, gender)

3.集合

1.什么是集合(set)

1)集合是容器型数据类型；将{}作为容器的标志里面多个数据用逗号隔开：{数据1，数据2，数据,…}
2)集合是可变的(支持增删改);集合是无序的
3)集合对元素的要求和字典对键的要求一样：不可变类型的数据、是唯一的

1)空集合

s1 = set()
print(s1, type(s1), len(s1))  # set() <class 'set'> 0

s1 = set(1)
s1 = {1,}#表示集合中只有一个元素

2)集合是无序的

print({10, 20, 30} == {20, 10, 30})  # True

3)集合的元素必须是不可变的数据

s1 = {'abc', 10, 12, 3, (10, 20)}  # True
# s2={'abc',10,12,3,[10,20]}#因为列表是可变的，则会报错

4)集合的元素是唯一的

s2 = {10, 20, 30, 20, 10, 10}
print(s2)  # {10, 20, 30}

names = ['张三', '李四', '小明', '张三', '小明']
print(set(names))  # 将列表转换为集合，进行去重

2.数字集合运算：

​ 交集、并集、差集、子集和真子集

1）交集

​ - 求两个集合的公共部分

集合1 & 集合2

print(s1 & s1)#{5, 6, 7}

2）并集

​ - 将两个集合合并成一个集合

集合1 | 集合2

print(s1 | s2)#{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

3）差集

​ - 去掉一个集合中包含在另外一个集合的部分，剩下的部分

集合1 - 集合2

print(s1 - s2)#{1, 2, 3, 4}
print(s2 - s1)#{8, 9, 10}

4）对称差集

​ - 去掉两个集合公共部分后剩下的部分

集合1 ^ 集合2

print(s1 ^ s2)#{1, 2, 3, 4, 8, 9, 10}

5）子集、真子集

注意：这里的比较运算符不是比较大小

a.子集

集合1 >= 集合2 - 判断集合2是否是集合1的子集

集合1 <= 集合2 - 判断集合1是否是集合2的子集

b.真子集

集合1 > 集合2 - 判断集合2是否是集合1的真子集

集合1 < 集合2 - 判断集合1是否是集合2的真子集

{1,2,3}的子集：{}、{1}、{2}、{3}、{1,2}、{1,3}、{2,3}、{1,2,3}

{1,2,3}的真子集：{}、{1}、{2}、{3}、{1,2}、{1,3}、{2,3}

a.子集: 集合1 >= 集合2 - 判断集合2是否是集合1的子集

print({1} <= {1, 2, 3})  # True

print({100, 200, 300, 400} > {1, 2})  # False

4.字符串

1.什么是字符串

1）字符串是容器型数据类型，可以同时保存多个文字符号；将单引号、双引号作、三个单引号、三个双引号为容器标志，引号中的每个符号就是字符串中的每个元素

str1 = '小明'
str2 = "小明"
str3 = '''小明'''
str4 = """小明"""

msg = '窗前明月光，' \   #加一个\就在写入字符串时可换行，打印时，不会换行
      '疑是地上霜'
print(msg)#窗前明月光，疑是地上霜

msg = '''窗前明月光，
      疑是地上霜'''
print(msg)				#在""" """或者''''''中可以随便换行
#窗前明月光，
#      疑是地上霜


def func1():
    """函数说明文档"""
    """hello world"""
    

2）字符串是不可变的，字符串是有序的

print('abc' == 'bac')		#False

3）元素：引号中每个独立的符号都是字符串的元素，字符串的元素又叫字符

​ 可以使任何国家任何名族的任何语言符号（英文符号、中文符号、阿拉伯数字、韩语、日语），还可以是转义字符

4）空串

引号中没有任何符号的字符串（引号中有空格的时候不是空串）

str5=''
print(type(str5),len(str5))#<class 'str'> 0

2.字符

字符串每一个独立的符号（字符串的元素）

字符串中的字符分为两种：普通字符、转义字符

并不是所有的符号前加 \ 都会变成转义字符

1）普通字符

​ - 在字符串中表示符号本身的字符就是普通字符

2）转义字符

• 在字符串中有特殊意义或者特殊功能的符号就是转义字符

转义字符 - 在特定的符号前加入 \ 来表示特殊功能或者特殊意义的符号

​ \t #水平制表符（相当于一个teb键）
​ \n、 \r #换行
​ \ ’ #表示一个普通的单引号
​ \ " #表示一个普通的双引号
​ \ \ #表示一个普通的反斜杠

str = '\tabc\n123\m'
print(str)		#	abc
				#123\m
    
str1 = 'it\'s me'
print(str1)		#it's me

str2 = 'I say:"good good study, day day up"'
#str2 = "I say:\"good good study, day day up\""
#str2 = 'hi,It\'s me! I say\:"good good study, day day up\"'
print(str2)

str3 = '\\abc'
print(str3)			#\abc

str4 = 'abc\\n123'
print(str4)  		# abc\n123

str5 = 'c:\\name\\yuting\\test\\demo.py'
print(str5)			#c:\name\yuting\test\demo.py

3）r字符串

在字符串的引号前面加r或者R，可以让字符串中所有的转义字符功能消失（让字符串都变成普通字符）

str1 = r'\tabc123'
print(str1)  # \tabc123

path = R'C:\names\proms\python\test\a.txt'
print(path)  # C:\names\proms\python\test\a.txt

3.字符编码

二极管

计算机存储数据只能存数字（存的是数字的二进制补码）

1.字符编码

为了你能够让计算机存储文字符号，给每个符号对应了一个固定的数字，每次在需要存储这个符号的时候，就去存储这个固定的数字。
每个对应的那个数字就是这个符号的编码值。

查看图片是如何存储在计算机的，查看pillow(PIL)

2.编码表

- 保存字符和字符对应编码值的表

1)ACSII码表

美国信息码（只包含了美国人常用的符号，总共128个）
数字字符：(0-48 ~ 9-57)
大写字母：(A-65 ~ Z-90) 小写字母： (a-97 ~ z-122)
英文输入法下的特殊字符

2)Unicode编码表(Python)

包含了世界上所有的国家所有的名族的所有的语言符号
Unicode编码表包含了ACSII（前128个字符就是ASCII码表中的内容）
中文编码范围：4e00 ~ 9fa5

3.编码值的应用

1）chr(编码值)

• 获取编码值对应的字符

print(chr(97))  # 'a'
print(chr(0x4e00))  # '一'
print(chr(0x9fa5))  # '龥'
from pypinyin import pinyin #打印中文的拼音

for x in range(0x4e00, 0x9fa5 + 1):
    print(chr(x), pinyin(chr(x)), end=' ')

2）ord(字符)

• 获取指定字符对应的编码值

注意: 字符指的是长度为1的字符串

print(ord('a'))  # 97
print(ord('余'))  # 20313

# 将char对应的小写字母转换成大写字母
# 将'm'->'M'
char = 'm'
print(chr(ord(char) - 32))  # M

3）编码字符：\u + 4位的16进制编码值

在字符串中提供字符的方式有两种：a.直接提供字符 b.使用编码字符

# hex(10进制数)    -   如果编码值是10进制数，则可以通过hex() 获取对应的16进制表示方式
print(hex(97))  # 0x61 -a

str1 = 'ab你好'
print(str1)

# 如果知道字符编码值是多少，但是不知道字符是什么的时候，就可以使用编码字符来表示这个字符
str2 = '\u0061'
print(str2)  # a

# 判断字符是否是中文
char = '块'
if '\u4e00' <= char <= '\u9fa5':
    print(char, '是中文')
else:
    print(char, '不是中文')

# 判断字符是否是英文
char = '67'
if 'a' <= char <= 'z':
    print(char, '是英文')
else:
    print(char, '不是英文')

4.查 - 获取字符

1）查单个

：字符串[下标] - 获取指定下标对应的元素*

str1 = '\thello world'
print(str1[1])		#h
print(str1[-2])		#d

2）字符串切片

字符串[开始下标：结束下标：步长]

str1='good good study!'
print(str1[1:-2:2])#odgo td
print(str1[-3:])#dy!

3）遍历字符串

a. for 变量 in 字符串：

​ 循环体

b. for 变量 in range(len(字符串)):

​ 循环体

c. for index,item in enumerate(字符串):

​ 循环体

for x in str1:
    print(x)


for index in range(len(str1)):
    print(index, str1[index])


for index, item in enumerate(str1):
    print(index, item)

5.字符串的相关操作

1）字符串加法运算

• 字符串拼接

字符串1+字符串2 - 将两个字符串合并产生一个新的字符串

# 在字符串str4中每个字符的后面加一个*
ny ='abds'
new_ny= ''
for x in ny:
    new_ny += x + '*'
print(new_ny)		#a*b*d*s*


# 案例2：在每一个数字字符后面插入一个%
str1 = '世界上79899kjhk;;//sha6=2'
new_str1 = ''
for x in str1:
    if '0' <= x <= '9':
        new_str1 += x + '%'
    else:
        new_str1 += x
print(new_str1)  # 世界上7%9%8%9%9%kjhk;;//sha6%=2%

2）字符串乘法运算

字符串 * N、N *字符串 - 将字符串中重复N次产生一个新的字符串

str1 = 'hello'
print(str1 * 3)     # 'hellohellohello'

3）字符串比较运算

比较一对不相等的字符的大小 - 比较的是第一对不相等的元素的大小

（字符串比较大小比较的是字符串的编码大小）

判断字符的性质：

​ 是否是数字字符：‘0’ <= x <= ‘9’
​ 是否是小写字母：‘a’ <= x <= ‘z’
​ 是否是大写字母：‘A’ <= x <= ‘Z’
​ 是否是字母：‘a’ <= x <= ‘z’ or ‘A’ <= x <= ‘Z’
​ 是否是中文：‘\u4e00’ <= x <= ‘\u9fa5’

判断’21’>‘123’ True

判断’abcc’>‘MS’ True 因为在电脑编码里 a的编码值比M大

判断‘21’>‘237’ False 因为首位一样 则判断下一位的编码大小，1的编码比3小

print('abc' > 'bcc')  # False 'a'>'b'
print('a1mn' > 'abc')  # False '1'>'b'
print('a你好' > 'abc')  # True '你'>'b'

#提取字符串中所有的数字字符
str = 'sadgags243556jsdgk53'
new_str = ''
for x in str:
    if '0' <= x <= '9':
        new_str += x
print(new_str)

4）in和not in

字符串1 in字符串2 - 判断字符串1是否是字符串2的子串（判断字符串2是否包含在字符串1中）

str1 = 'abc1234'
print('a' in str1)
print('ab' in str1)  # True
print('ac' in str1)  # False

6.字符串的相关函数

1）max、min、sorted

print(max('hello world'))  # w
print(sorted('helloworld'))  # ['d', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

2）len(字符串)

msg = '\thello\nworld!\u4e00'
print(len(msg))  # 14

3）str(数据)

• 任何类型的数据都可以转换成字符串；转换的时候是在数据的打印值外面加引号

str(100)
str(1.23)
print([str(100)])  # ['100']

list1 = [10,20,30,40]
print(list1)        # [10, 20, 30, 40]
print(str(list1))  # '[10, 20, 30, 40]'
# 当list1的格式不标准时，由于list1的打印值是标准的，则就是直接在打印值外面加引号

list2=["余婷",18,'女']
print(list2)        # ['余婷', 18, '女']
print(str(list2))   # ['余婷', 18, '女']

4) eval(字符串)

• 去掉字符串的引号，获取引号中表达式的结果

print(eval('100'))  	# 100
print(eval('1.23'))  	# 1.23
# eval('abc')			# name 'abc' is not defined

abc = 100 				#为变量abc赋值
print(eval('abc'))  	# 100 eval就可以引用abc变量

a1 = eval('[10,20,30]')
print(a1)  				# [10, 20, 30]
a1.append(100)
print(a1)  				# [10, 20, 30, 100]

b1 = eval('10+20')
print(b1)  				# 30

msg = 'print(100)'
eval(msg)  				# 100

a = int(input('请输入数字a的值：'))
b = int(input('请输入数字b的值：'))
value = input('请选择运算符（+、-、*、/）:')
result = eval(f'a{value}b')
print(result)
# 请输入数字a的值：2
# 请输入数字b的值：4
# 请选择运算符（+、-、*、/）:+
# 6

7.字符串的相关方法

1.字符串.join()

• 将序列中的元素用指定的字符串连接成一个新的字符串（序列中的元素必须全部是字符串）

list1 = ['小明', '张三', '李四', '王五']
result = '+'.join(list1)
print(result)  # 小明+张三+李四+王五

result = 'and'.join(list1)
print(result)  # 小明and张三and李四and王五

result = '**'.join('abc')
print(result)  # a**b**c

nums = [90, 78, 67, 45, 23]  # ['90','78','67'....]
# '90+78+67+45+23'
result = '+'.join([str(x) for x in nums])
print(result)  # 90+78+67+45+23
print(eval(result))  # 303

2.字符串1.count(字符串2)

• 统计字符串1中字符串2的个数

msg = 'how are you? i am fine! thank you,and you?'
print(msg.count('a'))  # 4
print(msg.count('you'))  # 3

3.字符串.split()

• 将字符串1中所有的字符串2作为切割点对字符串1进行切割

msg = 'how are you? i am fine! thank you,and you?'
result = msg.split('you')
print(result)  # ['how are ', '? i am fine! thank ', ',and ', '?']

result = msg.split(' ')
print(result)  # ['how', 'are', 'you?', 'i', 'am', 'fine!', 'thank', 'you,and', 'you?']

result = msg.split(' ', 3)  # 从第三个空格开始后不切割
print(result)  # ['how', 'are', 'you?', 'i am fine! thank you,and you?']

4.字符串.replace()

• 1）字符串1.replace(字符串2，字符串3) - 将字符串1中所有的字符串2都替换成字符串3

• 2）字符串1.replace(字符串2，字符串3，N) - 将字符串1中前N个字符串2都替换成字符串3

msg = 'how are you? i am fine! thank you,and you?'
result = msg.replace('you', 'me')
print(result)  # how are me? i am fine! thank me,and me?

result = msg.replace('you', '+', 2)
print(result)  # how are +? i am fine! thank +,and you?

5.字符串.strip()

• 去掉字符串前后的空白字符
• 字符串.strip(‘/’) 去掉字符串前后的’/’

msg = """ 

    msg = how are you? i am fine! thank you,and you?

"""
print(msg.strip())
#msg = how are you? i am fine! thank you,and you?

msg = '///小/明\\\\\\//'
print(msg.strip('/'))  # 小/明\\\

6.字符串.isupper()

• 判断字符是否是大写字母

print('JGHJDK'.isupper())  # True
print('A'.isupper())  # True

7.字符串.islower()

• 判断字符或者字符串是否全是小写字母

print('hghjk'.islower())  # True
print('g'.islower())  # True

8.字符串.isdigit()

• 判断字符或者字符串是否全是数字字符

print('9'.isdigit())  # True
print('57789'.isdigit())  # True

9.字符串.upper()

print('hgj技术活后即可789hsjkdf'.upper())
# HGJ技术活后即可789HSJKDF

10.字符串.lower()

print('GHKJKDHAFJ规划局开始VBhjkjkljndf'.lower())
# ghkjkdhafj规划局开始vbhjkjkljndf

# 案例：判断char是否是字母
char = 's'
if char.islower() or char.isupper():
# if 'a' <= char <= 'z' or 'A' <= char <= 'Z'
    print('是字母')
else:
    print('不是字母')

8.字符串的格式化

1.字符串拼接

# 解决问题：字符串内容不确定
name = input('请输入学生的名字：')
age = int(input('请输入学生的年龄：'))
money = float(input('请输入你的月薪：'))
msg = name + '今年' + str(age) + '岁，月薪：' + str(money) + '元！'
print(msg)  # 小明今年34岁，月薪：12000.0元！

2.格式字符串

• 包含格式占位符的字符串

1）语法：包含格式占位符的字符串%（数据1,数据2,数据3,…）
2）注意：()中的数据必须和前面字符中的占位符一一对应
3）常见的格式占位符：
%s - 可以给任何类型的数据占位
%d - 可以给任何数字占位(整数占位符，如果给的数字是小数，会自动转换成整数再拼接到字符串中)
%f - 可以给任何数字占位(浮点数占位)
%.Nf - (控制保留N位小数)

name = input('请输入学生的名字：')
age = int(input('请输入学生的年龄：'))
money = float(input('请输入你的月薪：'))
msg = '%s今年%s岁，月薪：%.2f元！' % (name, age, money)
print(msg)  # 小明今年34岁，月薪：12000.00元！

result = '%s-%d-%f' % ([10, 20], 2.3, 3)
print(result)  # [10, 20]-2-3.000000

3.f-string

• 在字符串的最前面（引号的前面）加f,就可以在字符串中通过{表达式}中表达式的结果给字符串提供内容

name = input('请输入学生的名字：')
age = int(input('请输入学生的年龄：'))
money = float(input('请输入你的月薪：'))
msg = f'{name}今年{age}岁，月薪：{money}元！'
print(msg)#小明今年22岁，月薪：12000.0元！

• {表达式:.Nf} - 控制小数保留N位小数

a = 100
b = 20
# 'xxx + xx = xxx'
print(f'{a}+{b}={a + b:.2f}')  # 100+20=120.00

• {表达式:,.Nf} - 标准的金额拼接

# 357800    -> ￥357,800.00
d = 357800
print(f'￥{d:,.2f}')  # ￥357,800.00

5.深拷贝和浅拷贝

1）深拷贝

拷贝的程度深，自己新开辟了一块内存，将被拷贝内容全部拷贝过来了；

是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联

2）浅拷贝

拷贝的程度浅，只拷贝原数据的首地址，然后通过原数据的首地址，去获取内容。

指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。

• 使用数据类型本身的构造器
• 对于可变的序列，还可以通过切片操作符 : 来完成浅拷贝
• Python 还提供了对应的函数 copy.copy() 函数，适用于任何数据类型

两者的优缺点对比：
（1）深拷贝拷贝程度高，将原数据复制到新的内存空间中。改变拷贝后的内容不影响原数据内容。但是深拷贝耗时长，且占用内存空间。
（2）浅拷贝拷贝程度低，只复制原数据的地址。其实是将副本的地址指向原数据地址。修改副本内容，是通过当前地址指向原数据地址，去修改。所以修改副本内容会影响到原数据内容。但是浅拷贝耗时短，占用内存空间少。

对于可变的数据类型（列表、字典），浅拷贝后的地址会发生改变

对于不可变的数据类型（元组、字符串），浅拷贝后的地址不会发生改变

有两层数据类型，外层为可变数据类型，内层为可变数据类型

其他情况具体如下

浅拷贝看的是外层数据类型，内层地址不变

深拷贝则需看内层数据类型，内层为可变的数据类型，则内层地址会变。外层是可变的，外层就可变；外层为不可变，则不可变

若内层地址不变 则浅拷贝的时候，会拷贝更改后的对象

import copy

a = [1, 2, 3, 4, ['a', 'b']]

b = a  # 赋值
c = a[:]  # 浅拷贝
d = copy.copy(a)  # 浅拷贝
e = copy.deepcopy(a)  # 深拷贝

a.append(5)
a[4].append('c')

print('a=', a)  # a= [1, 2, 3, 4, ['a', 'b', 'c'], 5]
print('b=', b)	# b= [1, 2, 3, 4, ['a', 'b', 'c'], 5]
print('c=', c)  # c= [1, 2, 3, 4, ['a', 'b', 'c']]
print('d=', d)  # d= [1, 2, 3, 4, ['a', 'b', 'c']]
print('e=', e)  # e= [1, 2, 3, 4, ['a', 'b']]