目录
1.常见的容易遗忘的知识点
a.随机数,随机数组的生成
Python自带的random库
import random
print(random.randint(0,10)) # 产生 1 到 10 的一个整数型随机数
print(random.random()) # 产生 0 到 1 之间的随机浮点数
print(random.uniform(1.1,5.4)) # 产生 1.1 到 5.4 之间的随机浮点数,区间可以不是整数
print(random.randrange(1,100,2)) # 生成从1到100的间隔为2的随机整数
print(random.choice([1,2,3,4,5,6,7,8,9,0])) # 从序列中随机选取一个元素
a = [1,3,5,7,9]
random.shuffle(a) # 用于将一个列表中的元素打乱
print(a)
numpy库
import numpy as np
print(np.random.rand(3,3,3)) # 产生n维的均匀分布的随机数
print(np.random.randn(3,3,3)) # 产生n维的正态分布的随机数
print(np.random.randint(1,50,10)) # 产生n--m之间的k个整数
print(np.random.random(10)) # 产生n个0--1之间的随机数
print(np.random.choice([1,3,5,7,9])) # 从序列中选择数据
# 把序列中的数据打乱
a = [1,3,5,7,9]
np.random.shuffle(a)
print(a)
注意
python 自带的 random库和 numpy中的random库中的randint()在使用中有如下区别:
random.randint(1,10)
# random.randint(1,10,7) # 错误用法
np.random.randint(1,10,7)
应用1:生成指定数量的字符串
import random
alphabet = 'abcdefghijklmnopqrstuvwxyz!@#$%^&*()'
characters1 = random.sample(alphabet,10)
print(characters1) # ['p', 'm', '^', 't', 'd', 'z', 'i', 'o', '$', '(']
characters2 = ''.join(random.sample(alphabet,10))
print(characters2) # ask%nl$!vr
应用2:从a-zA-Z或者0-9生成指定数量的随机字符
import random
import string
value1 = ''.join(random.sample(string.ascii_letters,8))
value2 = ''.join(random.sample(string.digits,8))
print(value1) # TEAsStBn
print(value2) # 75963012
b.map的简单使用
height,weight = map(float,input('输入身高,体重').split())
height,weight
执行过程:
输入:输入身高,体重175 70
结果:(175.0, 70.0)
c.range的使用
"""
range(N) - 产生一个[0,N)的数字序列 N > 0
range(M,N) - 产生一个[M,N)的数字序列 M < N
range(M,N,step) - 产生一个[M,N)的数字序列
step为步长(每次数字增加的值) M < N
:注意步长可以为负
自己的理解:range()函数在使用时,无论步长正负,生成的数是一个左闭右开的数字序列。
左边的数字一定可以取到,右边的数字一定取不到。
"""
for x in range(0,10):
print('x:',x) # 输出:0-9
for x in range(10,0,-1):
print('x:',x) # 输出:10-1
d.continue 和 break 的使用
用于测试的for 循环
for i in range(4):
print(i,'+++++')
print(i,'-----')
"""
0 +++++
0 -----
1 +++++
1 -----
2 +++++
2 -----
3 +++++
3 -----
"""
循环里含continue
for i in range(4):
print(i,'+++++')
if i%2==0:
continue
print(i,'-----')
else:
print('无异常')#判断循环是否正常执行
# 0 对任何数取余都等于0
"""
0 +++++
1 +++++
1 -----
2 +++++
3 +++++
3 -----
无异常
"""
循环里含break
for i in range(4):
print(i,'+++++')
if i%2==0:
break
print(i,'-----')
else:
print('无异常')#判断循环是否正常执行
# 0 +++++
两层循环嵌套,break在内层循环
# break只能结束当前代码块中的循环,不能结束更外层的循环
# for 或者 while 循环中出现break时,循环不会正常结束,后面如果有else,else中的内容是不会执行的
# for 或者 while 循环中出现continue时,循环仍旧可以正常结束,后面如果有else,else中的内容是会正常执行的
for j in range(2):
print(f'第{j}次外层循环')
for i in range(4):
print(i,'+++++')
if i%2==0:
break
print(i,'-----')
else:
print('无异常')#判断循环是否正常执行
"""
第0次外层循环
0 +++++
第1次外层循环
0 +++++
"""
e.推导式
列表推导式
推导式的嵌套使用
import random
names = ['白起', '庄周', '狄仁杰', '吕布', '达摩']
courses = ['语文', '数学', '英语']
n, m = len(names), len(courses)
table1 = [[random.randint(60,100) for _ in range(m)]for _ in range(n)]
table1 # [[67, 97, 60], [75, 86, 96], [84, 66, 75], [79, 80, 88], [82, 60, 65]]
推导式的灵活使用(和enumerate 结合的嵌套)
接着上面的内容:要求计算并输出每一科的最高,最低分以及标准差
尝试:
最终代码:
import numpy as np
for j,course in enumerate(courses):
temp = [scores[i][j] for i in range(len(names))]
print(f'{course}科目的最高分为:{max(temp)}\n最低分为:{min(temp)}\n标准差为:{np.std(temp):.1f}\n')
print('-'*30)
后续处理:(也很重要)
import numpy as np
scores = np.array(table1).reshape(5,3)
scores
"""
array([[ 89, 80, 97],
[ 85, 84, 81],
[ 80, 81, 71],
[ 73, 100, 66],
[ 63, 85, 94]])
"""
import pandas as pd
df = pd.DataFrame(data = scores,index = names,columns = courses)
df
"""
语文 数学 英语
白起 61 84 90
庄周 88 65 79
狄仁杰 89 64 91
吕布 67 95 63
达摩 93 83 93
"""
推导式和条件语句的结合
nums2=[19,80,76,4,3]
result2=[x**2 for x in nums2 if x%2]
print(result2) # [361, 9]
推导式和三目运算符的结合
nums2=[19,80,76,4,3]
result2=[x*2 if x%2 else x//2 for x in nums2]
print(result2) # [38, 40, 38, 2, 6]
字典推导式
2.list , tuple , dict , set,字符串
2.1 list
切片
在对list进行切片时:
1.先看步长,步长省略则默认为1(即从前到后)
2.再看起始点到终点的方向和步长是否匹配(有取不到值的情况)
3.一般情况下,起始点一定会取到,终点即使为-1时,对应值也取不到。除非终点值省略的情况下,默认取到最后一个。
列表的排序(sort:直接在原列表排序;sorted:返回排序后的拷贝副本,不会修改原列表)
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)
# sorted函数返回列表排序后的拷贝不会修改传入的列表
# 函数的设计就应该像sorted函数一样尽可能不产生副作用
list3 = sorted(list1, reverse=True)
# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
print(list1)
print(list2)
print(list3)
print(list4)
# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)
增删改查以及其他相关函数
忘的比较多请看自己之前的总结
a.
列表.append(元素) - 在列表的最后添加指定的元素,放到最后
列表.pop() - 方法删除列表中的最后一个元素
列表.insert(下标,元素) - 在列表的指定下标前插入元素
b.
del 列表[下标] - 删除列表中指定元素下标对应的元素
列表.remove() - 删除列表中指定的元素,如果有多个只删除第一个,
如果没有该元素,会报错
列表.pop(下标) - 取出指定下标对应的元素
c.
列表[下标]=新元素 修改列表中指定下标对应的元素改为新元素
d.
其他操作:
列表1 + 列表2 - 将两个列表合并,产生新列表
列表 * N - 将列表中的元素重复N次,产生一个新的列表
比较运算:== ,!=,>,<,>=,<=
比较是否相等(长得一模一样)
比较大小(比较的是第一对儿不相等的元素的大小)
元素 in 列表 - 判断元素是否在指定列表中
元素 not in 列表 - 判断元素是否不在指定列表中
e.
相关函数:max,min,sorted,sum,list,len
max():获取列表中最大的元素 ,min():获取列表中最小的元素
列表中的元素类型需要一致,并且元素本身支持比较元素
sorted(列表) :将列表中的元素从小到大排序,排序后产生一个新列表,原列表还在
sorted(列表,reverse=True) : 从大到小
sum(列表) - 求列表中所有元素的和(必须是数字列表)
list(序列) - 将序列转换成列表(将序列中所有的元素取出,创建一个新列表)
所有的序列都可以转换成列表
f.
列表.clear() 清空列表(删除列表中的所有元素),比直接赋空值效率高
g.
列表.copy() - 复制原列表产生一个一模一样的新列表,将新列表返回
变量保存数据其实是保存的数据在内存空间中的地址
注意:
列表[:],列表+[],列表*1的功能和列表.copy()的功能一模一样
h.
列表.count(元素 - )统计列表中指定元素的个数
i
列表.extend(序列)- 将指定序列中的所有的元素全部添加到列表的后面
l1=[1,2]
l2=l1.copy()
l1.append('abc') #[1, 2, 'abc']
l2.extend('abc') #[1, 2, 'a', 'b', 'c']
j.
列表.index - 获取指定元素在列表中的下标(下标是0开始增加的下标值)
同一元素有多个时,只返回第一个的下标值
元素不存在时,会报错
k.
列表.reverse() - 将原列表倒序
l.
列表.sort() - 直接修改原列表中元素的顺序,从小到大排序,不会产生新的列表
sorted.(列表),是返回一个新建立的有序列表,从小到大
2.2 tuple
详情参考自己总结的知识点
元组就是不可变的列表 - 列表中除了增删改以外的操作都适用
可以排序,但是输出值是列表,想要元组再进行类型转换
在没有歧义的情况下,元组的小括号可以省略
直接将多个数据用逗号隔开,也表示一个元组
让变量的个数小于元组中元素的个数,并且在其中的一个变量前加*
获取的时候先让不带的变量按位置获取对应元素,剩下的全部给有的
student=('小明',18,89,78,23,8,'男')
name,*others,sex=student
print(name,sex) #小明 男
print(others) #[18, 89, 78, 23, 8]
name,age,*s,sex=student
print(name,age,sex)
print(*s) #89 78 23 8
print(s) #[89, 78, 23, 8]
元组只有一个元素,必须在唯一元素后添加逗号
t7=(1,)
2.3 dict (具体参考自己写的知识点)
每个元素都是键值对:{键1:值1,键2:值2,…}
字典是可变的(支持增删改);
字典是无序的(不支持下标操作)
增删改查
查
字典[key] - 获取字典中指定key对应的值
字典.get(key) - 获取字典中指定key对应的值,key不存在返回None
字典.get(key,默认值) - 获取字典中指定key对应的值,key不存在返回默认值
增,改
字典[key] = 值 - 当key存在的时候就是修改指定key对应的值,
当key不存在的时候添加键值对
删
- del 字典[key] - 删除字典中指定key对应的键值对
- 字典.pop(key) - 取出字典中指定key对应的值
字典相关操作
1)字典不支持+、* 和 比较大小,只支持比较是否相等的运算
2)in 和 not in - 判断字典中是否存在指定的key
3)dict,len
dict(数据) - 将数据转换成字典
a. 数据必须是序列
b. 序列中元素必须是小序列, 而且小序列有且只有两个元素,第一个元素必须是不可变的
list1 = [(10, 20), 'ab', range(2)]
print(dict(list1)) # {10: 20, 'a': 'b', 0: 1}
#将字典转化为列表类型时,列表里只保存键
dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = list(dog)
print(result) # ['name', 'age', 'breed', 'gender']
print(len(dog)) # 4
字典推导式
{表达式1:表达式2 for 变量 in 序列}
{表达式1:表达式2 for 变量 in 序列 if 条件语句}
dict(表达式 for x in 序列) - 表达式必须是有且只有两个元素的序列,第一个元素必须是不可变的
result = {x: x**2 for x in range(3)}
print(result) # {0:0, 1:1, 2:4}
result = {x: None for x in ['name', 'age', 'gender']}
print(result) # {'name': None, 'age': None, 'gender': None}
result = {x: x//2 for x in range(11, 20) if x % 2 == 0}
print(result) # {12:6, 14:7, 16:8, 18:9}
dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = {dog[x]: x for x in dog}
print(result) # {'财财': 'name', 2: 'age', '中华田园犬': 'breed', '母狗': 'gender'}
result = dict((dog[x], x) for x in dog)
print(result) # {'财财': 'name', 2: 'age', '中华田园犬': 'breed', '母狗': 'gender'}
字典相关方法
-
字典.clear() - 清空字典
-
字典.copy() - 复制字典产生一个一模一样的新字典
-
(了解)dict.fromkeys(序列) - 创建一个字典,将序列中所有的元素作为字典key,值默认都是None
-
values、keys、items
字典.values() - 获取字典中所有的值;返回的不是列表另是一种序列
字典.keys() - 获取字典中所有的键;返回的不是列表另是一种序列
字典.items() - 获取字典中键值对;返回的时候序列,序列中的元素是每个键值对对应的元组 -
字典.setdefault(key, value) - 在字典中添加键值对(不会在key存在的时候进行修改操作)
-
字典.update(序列) - 将序列中所有的元素作为键值对添加到字典中。
序列必须是可以转换成字典的序列
字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中 -
两个列表生成字典
products = ['A1', 'B', 'C', 'E', 'a', 'b']
company = ['parent', 'parent', 'parent', 'parent', 'branch', 'branch']
print(dict(zip(company,products))) # {'parent': 'E', 'branch': 'b'}
print(dict(zip(products,company))) # {'A1': 'parent','B': 'parent','C': 'parent','E': 'parent','a': 'branch','b': 'branch'}
2.4 set
集合是容器型数据类型:将{}作为容器的标志,多个元素之间用逗号隔开:{元素1,元素2,元素3…}
集合是可变的
集合是无序的
元素:a.必须是不可变的数据
b.元素是唯一的
set2={'abc',123,(2,3)}
增删改查
1)查 :遍历
2)增:
集合.add(元素) - 集合中添加指定元素
集合.update(序列)- 将序列中的元素全部添加到集合中
3)删:
集合.remove(元素) 删除指定元素,如果元素不存在,会报错
集合.discard(元素) 删除指定元素,如果元素不存在,不会报错
4)改:
不能直接修改某个元素,只能先删再加
2.5 四种容器型数据对比总结
列表 | 字典 | 元组 | 集合 | ||
---|---|---|---|---|---|
类型名 | list | dict | tuple | set | |
容器标志 | [n1,n2,n3,…] | {‘键1’:‘值1’} | (n1,n2,n3,…) | {n1,n2,n3,…} | |
容器的特点 | 可变,有序 | 可变,无序 | 不可变,有序 | 可变,无序 | |
增删改查 | 1.增:append,insert 2.删:del,remove,pop 3.改:list1[下标]=值 4.查: a:list1[下标] b:list1[开始下标:结束下标:步长] c:遍历 | 1.增:字典[key]=值,setdefault(key,value) 2.删:del,pop 3.改:字典[key]=值 4.查: a:字典[key] b:字典.get(‘key’) c:遍历 | 1.查:同列表 2.多个变量方法(用于赋值等) | 1.增:add,update 2.删:remove,discard 3.查:遍历 4.数学集合运算:|,&,-,^,>,<,>=,<= | |
相关操作 | +,*,比较大小,比较相等,in,not in,max,min,sum,list,len | 比较相等,in,not in,dict,len | 同列表 | 比较相等,in,not in,max,min,set,len | |
相关方法 | list.append() list.insert() list.extend() list.pop() list.remove() list.clear() del list1[] list[n]=x list.count(元素) list.index(元素) | dict.setdefault(key,value) dict.get() dict.copy() dict.update() del dict[key] dict.clear() dict.keys() dict.values() dict.items() | tuple.clear() tuple.copy() tuple.count(元素) tuple.index(元素) | 不管 | |
怎么选择 | 保存多个意义相同的数据 | 保存多个意义不同的数据 | 保存不能被修改的多个数据 | 涉及去重,集合运算 | |
2.6 字符串
\u四位的十六进制数 - 表示四位的十六进制数编码值对应的字符
编码相关的函数:
a. chr(编码值) - 获取指定编码对应的字符,返回的数据的类型是字符串
print(chr(97)) # a
print(chr(0x4e00)) # 一
print(chr(0x4e01)) # 丁
b. ord(字符) - 获取字符编码值(字符用长度是1的字符串表示)
print(hex(ord('余'))) # 20313 0x4f59
print(hex(ord('婷'))) # 23159 0x5a77
##练习: 写一个程序将输入的小写字母字符转换成对应的大写字母
str4=input('请输入字母:')
list5=[chr(ord(x)-32) if 97<=ord(x)<=122 else x for x in str4]
result=''.join(list5)
print(result)
字符 in 字符串 - 判断字符串中是否存在指定的字符
字符串的最前面加r/R,能够让字符串中所有转义字符的功能消失,字符串中的每个符号都是普通字符
字符串重要方法:
- 字符串1.count(字符串2) - 返回字符串1中字符串2出现的次数
- 字符串.join(序列) - 将序列中的元素用指定的字符串拼接产生一个新的字符串。(序列中的元素必须是字符串)
2.7 字符串格式化
使用print()函数很容易输出各种对象,但print()函数无法输出设计复杂的格式。Python提供了字符串格式化的方法来处理复杂格式的字符串。
2.7.1 %符号格式化字符串
- 字符串格式化涉及到两个概念:格式和格式化,其中格式以%开头,格式化运算符用%表示用对象代替格式串中的格式,最终得到1个字符串。
- 字符串格式化的一般形式如图所示:
2.7.1.1 字符串格式的书写
[]
中的内容可以省略;- 简单的格式是%加格式字符,如%f、%d、%c等;
- 当最小宽度及精度都出现时,它们之间不能有空格,格式字符和其他选项之间也不能有空格,如%8.2f。
2.7.1.2 常用格式字符的含义
name='Lily'
age=18
print('我叫%s,今年%d岁'%(name,age))#一次转换多个对象,这些对象表示成一个元组形式,位置与格式化字符一一对应
我叫Lily,今年18岁
2.7.2 format()方法格式化字符串
format()方法是通过{}
和:
来代替传统%方式。一般形式如图所示:
format方法格式化时,可以使用位置参数,根据位置来传递参数;也可以通过索引值来引用位置参数,只要format方法相应位置上有参数值即可,参数索引从0开始;
print('我叫{},今年{}岁'.format('张三',18))
print('我叫{0},今年{1}岁'.format('张三',18))
print('我叫{1},今年{0}岁'.format(18,'张三'))
我叫张三,今年18岁
我叫张三,今年18岁
我叫张三,今年18岁
2.7.3 f-string格式化字符
f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去,实例如下:
name='张三'
age=18
print(f'我叫{name},今年{age}岁')
我叫张三,今年18岁
3. 迭代器,生成器
3.1迭代器
迭代器:实现了迭代器协议的对象
所谓迭代器协议就是两个魔术方法,如果一个类中有以下两个魔术方法,这个类的对象就是迭代器对象
# __iter__
# __next__
class FibIter:
def __init__(self,max_count):
self.max_count = max_count
self.a,self.b = 0,1
self.curr_count = 0
def __iter__(self):
return self
def __next__(self):
if self.curr_count < self.max_count:
self.a,self.b = self.b,self.a+self.b
self.curr_count +=1
return self.a
raise StopIteration()
fib_iter = FibIter(20)
print(next(fib_iter))
print(next(fib_iter))
print(next(fib_iter))
print('-'*15)
for value in fib_iter:
print(value)
"""
1
1
2
---------------
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
"""
3.2生成器: 迭代器的语法简化升级版本
def fib_iter(max_count):
a,b = 0,1
for _ in range(max_count):
a,b= b,a+b
yield a
一个生成等差数列的生成器
def seq_gen(m,n,k):
for i in range(m,n+1,k):
yield i
验证
gen = seq_gen(10,30,3)
for value in gen:
print(value)
另一种写法
def seq_gen2(m,n,k):
yield from range(m,n+1,k)
验证:
gen2 = seq_gen2(10,30,3)
for value in gen2:
print(value)
"""
10
13
16
19
22
25
28
"""
3.3 生成表达式
import random
# 生成表达式
gen = (random.randrange(1,100) for _ in range(5))
gen # <generator object <genexpr> at 0x000001DA67C8EEB0>
验证
for value in gen:
print(value)
"""
60
78
96
97
53
"""
4. 常用函数
4.1 strip()
说明:strip函数的作用是去除字符串头尾指定的字符。该函数的语法是: 要消除的字符串.strip(‘指定的字符’)
注意:strip函数只能去除首尾的字符。包括空格或者其他特殊字符,但无法去除中间的字符。
price = "1000元"
price_new = price.strip("元") #去除掉"元"字
print(price_new) # 输出:"1000"
price1 = " 100 0 "#前后各有一个空格
price1_new = price1.strip(" ") #去除掉空格
print(price1_new) # 输出:"100 0"
4.2 split()
split函数的作用是将字符串按照某个分隔符进行拆分,并返回一个包含拆分结果的列表。它的语法是: 要拆分的字符串.split(‘分隔符’)。
price2 = "1000-2000"
price2_new = price2.split("-") #将两个价格分隔开
print(price2_new) ['1000', '2000']
4.3 map()
map函数的作用是将函数应用于可迭代对象(例如列表)的每个元素,并生成一个新的结果。其基本语法是:map(作用于元素的函数, 可迭代对象)。
实际场景中,经常需要对一列数据应用同样的函数来达到我们想要的结果,这时候就需要用到map函数。
income = [50000, 80000, 100000, 120000, 75000, 60000, 55000, 58000, 90000, 65000,
72000, 56000, 68000, 70000, 150000, 140000, 48000, 54000, 95000, 110000,
78000, 89000, 67000, 55000, 92000, 60000, 80000, 75000, 62000, 48000,
69000, 75000, 85000, 90000, 98000, 55000, 62000, 70000, 88000, 56000,
66000, 75000, 59000, 87000, 72000, 62000]
def fd_income(x): #fd_income为函数名
#中间if函数部分为函数体
y = ''
if x < 50000:
y = "低收入家庭"
elif x>= 50000 and x< 100000:
y = '中等收入家庭'
else:
y = '高收入家庭'
return y #y为自定义函数的传出参数
fc_income = map(fd_income,income)
print(list(fc_income))
"""
['中等收入家庭', '中等收入家庭', '高收入家庭', '高收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '高收入家庭', '高收入家庭', '低收入家庭', '中等收入家庭', '中等收入家庭', '高收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '低收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭', '中等收入家庭']
"""
输入输出与数据持久化
类