前言
1.可变类型和不可变类型
python的数据都是报存在内存里的，python里的数据分为可变类型和不可变类型
- 不可变类型：字符串，数字，元组
- 可变类型：列表，字典，集合
不可变数据类型，如果修改值，地址不会发生变化，可变数据类型则会。
使用内置函数 id() 可以获取一个变量的内存地址。
一：字符串
1. 表示方式
a = 'hello'
b = "hello1"
c = '''hello2'''
d = """hello3"""
m = 'xiaoming said:"I am xiaoming"'
n = "I'm xiaoming"
p = """xiaoming said
"I
am what I am"
"""
转义字符：\
print('good \t you') # good you
# 在字符串前面加 r 在python里表示是原生字符串
print(r'hello \t each') # hello \t each
2. 下标和切片
下标（索引）：表示第几个数据。
切片：就是从字符串里复制一段指定的内容，形成新的字符串。
m = 'abcdefghijklmn'
# 获得指定下标
print(m[5])
# 获得切片
# 语法：m[start:end:step]
# （左闭右开）包含start不包含end
# step 指的是步长，理解为间隔。每隔 step-1 个取一次
# step 为负数，表示从右往左获取
print(m[4:7])
3. 常见操作
- 获取长度：len
- 查找内容：find, index, rfind, rindex
- 判断：startswith, endswith, isalpha, isdigit, isalnum, isspace
- 计算出现次数：count
- 替换内容：replace
- 切割字符串：split, rsplit, splitlines, partition, rpartition
- 修改大小写：capitalize, title, upper, lower
- 空格处理：ljust, rjust, center, lstrip, rstrip, strip
- 字符串拼接：join
注意：
在python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有的字符串，都是返回一个结果，是一个新的返回值。
4. 字符串前加（u、r、b、f）
r/R
表示非转义的原始字符串，比如在字符串中如果出现\n是换行，但是如果在字符串的前面添加r则表示\和n两个字符，一般常见于正则表达式中。
b
Python3里默认的str是(Python2里的)unicode, bytes是(Python2)的str, b前缀代表的就是bytes。 Python2里, b前缀没什么具体意义， 只是为了兼容Python3的这种写法。
作用：b" "前缀表示：后面字符串是bytes 类型。
u/U
表示unicode字符串 ，不是仅仅是针对中文, 可以针对任何的字符串，代表是对字符串进行unicode编码。 一般英文字符在使用各种编码下, 基本都可以正常解析, 所以一般不带u；但是中文, 必须表明所需编码, 否则一旦编码转换就会出现乱码。 建议所有编码方式采用UTF-8。
作用：后面字符串以 Unicode 格式 进行编码，一般用在中文字符串前面，防止因为源码储存格式问题，导致再次使用时出现乱码。
f/F
f-string: formatted string literals, 格式化字符串常量。
f-string在本质上并不是字符串常量，而是一个在运行时运算求值的表达式。
以大括号 {} 标明被替换的字段
功能同str.format() %-formatting,
较两者更简洁易用，推荐使用
需要注意的是，Python3.6及以后的版本可用。
name = 'tom'
print(f'你好，{name}‘)
# 你好，tom
list_ = [1,2,3]
print(list_, f'has a length of {len(list_)}.')
# [1,2,3] has a length of 3.
print(list_, f'has a length of {{len(list_)}}.')
# [1,2,3] has a length of {len(list_)}.
print(list_, f'has a length of {{{len(list_)}}}.')
# [1,2,3] has a length of {3}.
5. 字符集和编码
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n61AsRBC-1616139080393)(C:\Users\17812\Desktop\笔记(work)]\typora_images\image-20201201204528919-1616134896670.png)
- 使用内置函数 chr 和 ord 能够查看数字和字符的对应关系
# ord 获取字符对应的编码 chr 根据编码获取对应的字符
print(ord('a')) # 字符对应的编码是 97
print(chr(65)) # A
- 使用字符串的encode方法，可以将字符串转换成为指定编码集结果
print('你'.encode('gbk'))
7. 格式化字符串
格式化打印字符串
# 可以使用 % 占位符来表示格式化一个字符串
name = 'zhangsan'
age = 18
print('大家好，我是%s，我今年%d岁了', %(name,age) )
- %s 表示的是字符串的占位符
- %d 表示整数的占位符
- %nd 打印时，显示 n 位，如果不够，在前面使用空格补齐
- %f 表示的浮点数的占位符
- %.nf 保留小数点后 n 位
- %x 将数字使用十六进制输出
print('%%s') # 打印：%s
format方法
# 使用 {} 进行占位，{}里可以加东西
print('大家好，我是{}，今年{}岁'.format('zhansan', 11))
print('大家好，我是{1}，今年{0}岁'.format(11, 'zhangsan'))
print('大家好，我是{name}，今年{age}岁'.format(age=11, name='zhangsan'))
print('大家好，我是{name}，今年{0}岁'.format(11,name='zhangsan'))
d = ['zhangsan', 11]
print('大家好，我是{}，今年{}岁'.format(*d))
info = {'name':'zhangsan', 'age':11}
print('大家好，我是{name}，今年{age}岁'.format(**info))
二：列表
1.认识列表
创建列表
# 使用 []
names = ['zhangsan', 'tom', 'mike']
# list(可迭代对象)
names = list(('tom', 'mike', 'tony'))# ('tom', 'mike', tony')是元组
列表特点
- 可以使用下标来获取元素和对元素进行切片。
- 可以使用下标来修改列表里的元素。
- 可以存储任意数据类型。
方法
- 添加：append()
- 插入：insert()
- 拼合：extend(可迭代对象)
- 删除：
- pop ：删除列表里最后一个数据，并且返回这个数据，还可以传入index参数，用来删除指定位置上的数据
- remove ：删除指定数据，如果数据在列表中不存在则报错
- clear ：清空列表
- 查询：
- index() ：查询指定数据的索引
- count()：查询指定数据在列表中的个数
- 使用 in 运算符时 ，返回布尔值
tanks = ['zhangsan', 'jiszh']
print('zhangsan' in tanks) # True
- 修改：通过下标直接修改。如：
tanks[1] = 'lisi'
2.列表的操作
列表的遍历
- while循环遍历
peoples = ['tom','mike','jack','jimy']
i = 0
while i < len(peoples):
print(peoples[i])
i += 1
- for…in 循环遍历：for…in 循环的本质就是不断地调用next方法查找下一个数据。
peoples = ['tom','mike','jack','jimy']
for p in peoples:
print(p)
列表的排序
- sort()：调用列表的sort方法可以直接对列表进行排序。
- 加参数 reverse=True 可以反转排序。
nums = [1,2,3,5,4]
nums.sort()
nums.sort(reverse=True)
nums[::-1] # 也能实现反转排序
- sorted()：内置函数，不会改变原有的列表数据，会生成一个新的有序列表数据。
x = sorted(nums)
-
reverse()：调用列表的reverse()方法可以反转排序。
-
当排序的元素是字典时：
students = [{'name':'jack','age':18},{'name':'tom', 'age':10}]
del fool(e):
print('e = {}'.format(e))
# 结果：
# e = {'name':'jack','age':18}
# e = {'name':'tom','age':10}
return e['age'] # 告诉sort方法，按照元素的哪个属性进行排序。
# 需要传递参数key指定比较规则，key的类型是函数。
students.sort(key=fool)
# 在sort内部实现的时候，调用了fool函数，并且传入了一个参数，就是这里列表里的每一个元素。
总结：
students.sort(key=lambda e: e['age'])
列表的复制
x = [1,6,9,4,2,7]
y = x # 等号是内存地址的赋值，x,y指向同一个内存空间，会相互影响。这不是深拷贝也不是浅拷贝。
# 调用copy()方法，可以复制一个列表，这个新列表和原有列表内容一样，但指向不同的内存空间（地址不同）。
y = x.copy()
# 除了使用列表自带的copy()之外，还可以使用copy模块来实现拷贝。
import copy
a = copy.copy(x)
以上两种copy()都属于 浅拷贝（内容一样，地址不同）。切片就属于一种浅拷贝。
深拷贝，只能使用copy模块来实现。copy.deepcopy()。深拷贝的结果是两个完全独立的对象，没有羁绊。
import copy
words = ['hello','hi','good','bye',[1,2,3],'go']
words1 = words.copy() # words1是words的浅拷贝。
# 浅拷贝认为只拷贝了一层，内部其他层的指向没有拷贝。
words[0] = '你好' # 这时words1不受影响。
words[4,0] = 5 # 这时words1跟着变了。
words2 = copy.deepcopy(words2) # 深拷贝，words 和 words2完全独立不相干。
求列表里的最大数
- 方法一：先排序，再取出最大数。
- 方法二：a = 其中任一数，再与其他数比较，将较大值赋给a，最终得到最大值a。
删除列表里的空字符串
- 没有现成的方法，只能自己实现。
列表的嵌套
- 列表是可以嵌套的。等同于多维数组。
列表推导式
- 作用：使用简单语法创建一个列表
nums = [i for i in range(10)]
nums = [i for i in range(10) if i % 2 == 0]
points = [(x,y) for x in range(10) for y in range(10,20)] # 列表里面是元组。
三：元组
- 用来保存数据。
- 用一对小括号()来表示一个元组。
- 元组和列表的区别：
- 列表是可变的，元组是不可变数据类型。
words = ['hello','he','me'] # 列表，使用[] 表示
nums = (1,2,3,4,5) # 元组，使用()表示
nums[2] = 4 # 会报错，元组是不可变数据类型。
- 和列表一样，是一个有序的存储数据的容器，可以通过下标来获取元素。
nums[2] # 3
- 查询方法：调用元组里的方法
- index()
- count()：查询指定元素出现的次数。
- 特殊情况：
如何表示只有一个元素的元组？
age = (18) # 这种书写方式，age是一个整数，并不是一个元组。
age = (18,) # 加个逗号，就可以表示一个元组。
- 元组和列表之间转换
words = ['hello','he','me']
nums = (1,2,3,4,5)
num = tuple(words) # 列表转换为元组
word = list(nums) # 元组转换为列表
四：字典
1.认识字典
使用背景：列表的缺点。
# 定义一个列表保存：姓名、性别、职业。
nameList = ['xiaoZhang','男','木匠']
# 当修改职业的时候，需要记忆元素的下标。
nameList[2] = '花匠'
# 如果列表的顺序发生了变化：添加年龄。
nameList = ['xiaoZhang',18,'男','木匠']
# 此时需要记忆新的下标，才能完成职业的修改。
nameList[3] = '铁匠'
字典特点：
- 数据以键值对（key-value）保存的：不仅可以保存值，还能对值进行描述。
- key：不可重复的，重复则覆盖。只能使用不可变数据类型。
- value：可以使用任意数据类型。
- 使用 {} 来表示一个字典。key和value之间用冒号 ：连接。多个键值对之间用逗号 ，分隔。
- 字典是可变数据类型。
- 字典保存数据时是无序的。即不能通过下标获取元素。
2.字典的操作
字典内部提供了一系列方法供我们使用：
- 查询
person = {'name':'zhangsan', 'age':18}
person['name'] # 1.使用key获取对应的value值。
person.get('name') # 2.使用字典里的get()方法，如果获取的key不存在，不报错，而是 返回默认值（None）。
person.get('gender','felmare') # 可以这样设定默认值。
person.keys() # 获取所有的key
person.values() # 获取所有的value
- 修改、添加数据
person['name'] = 'lisi' # 直接使用Key可以修改对应的value。
person['gender'] = 'felmare' # 如果key不存在，则操作为往字典里添加一个新的键值对。
- 删除
person.pop('name') # 使用字典里的 pop()方法。返回值是被删的key对应的value。
person.popitem() # 字典里的 popitem()：删除一个元素，返回值是被删的键值对。
person.clear() # 字典里的 clear()：清空字典所有元素。
- update()
person1 = {'name':'hh','age':11}
person2 = {'addr':'shanghai','gender':'man'}
person1.update(person2) # 可以将两个字典拼在一起。
- 字典的遍历
person = {'name':'zhangsan', 'age':18,'addr':'shanghai','gender':'man'}
# 方式一：
for x in person:
print(x, '=', person[x])
# 方式二：
for k,v in person.items(): # 字典里的items()方法：返回一个列表，字典的每个键值对 对应列表的每个元组。
print(k,'=',v)
3.字典推导式
dict1 = {'a':100, 'b':200, 'c':300}
dict2 = {v:k for k,v in dict1.items}
四：集合
1.认识集合
集合（set）是一个无序的不重复元素序列，可以使用大括号{} 或者 set() 函数创建集合。
注意：创建一个空集合必须使用 set() 而不是{} ，因为{} 是用来创建一个空字典。
特点：
- 无序不重复：如果有重复的数据，会自动去除，不会报错。
2.操作
内部方法
- add() ：添加一个元素。
- pop()：删除一个元素。
- remove()：删除一个指定元素。
- union()：将多个集合合并成一个新的集合。
- update()：将一个集合拼到另一个集合里。
- clear()
集合里运算符的使用：
first = {'aa','bb','cc','dd'}
second = {'aaa','bbb','ccc','ddd'}
third = {'a','b','c','d'}
# 不支持 +
first - second # 求first和second的差集。
first & second # 求交集。
first | second # 求并集。
first ^ second # 求两者差集的并集。
四：集合
1.认识集合
集合（set）是一个无序的不重复元素序列，可以使用大括号{} 或者 set() 函数创建集合。
注意：创建一个空集合必须使用 set() 而不是{} ，因为{} 是用来创建一个空字典。
特点：
- 无序不重复：如果有重复的数据，会自动去除，不会报错。
2.操作
内部方法
- add() ：添加一个元素。
- pop()：删除一个元素。
- remove()：删除一个指定元素。
- union()：将多个集合合并成一个新的集合。
- update()：将一个集合拼到另一个集合里。
- clear()
集合里运算符的使用：
first = {'aa','bb','cc','dd'}
second = {'aaa','bbb','ccc','ddd'}
third = {'a','b','c','d'}
# 不支持 +
first - second # 求first和second的差集。
first & second # 求交集。
first | second # 求并集。
first ^ second # 求两者差集的并集。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
