自己容易遗忘的python基础知识点总结（2022.02.18 -02.）

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时，对应值也取不到。除非终点值省略的情况下，默认取到最后一个。

增删改查以及其他相关函数

忘的比较多请看自己之前的总结
a.
列表.append(元素) - 在列表的最后添加指定的元素,放到最后
列表.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不存在的时候添加键值对

删

1. del 字典[key] - 删除字典中指定key对应的键值对
2. 字典.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'}

字典相关方法

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

2)字典.copy() - 复制字典产生一个一模一样的新字典

3. (了解)dict.fromkeys(序列) - 创建一个字典，将序列中所有的元素作为字典key，值默认都是None

4） values、keys、items
字典.values() - 获取字典中所有的值；返回的不是列表另是一种序列
字典.keys() - 获取字典中所有的键；返回的不是列表另是一种序列
字典.items() - 获取字典中键值对；返回的时候序列，序列中的元素是每个键值对对应的元组

5. 字典.setdefault(key, value) - 在字典中添加键值对(不会在key存在的时候进行修改操作)

6)字典.update(序列) - 将序列中所有的元素作为键值对添加到字典中。
序列必须是可以转换成字典的序列
字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中

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. 字符串1.count(字符串2) - 返回字符串1中字符串2出现的次数
2. 字符串.join(序列) - 将序列中的元素用指定的字符串拼接产生一个新的字符串。（序列中的元素必须是字符串）

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. 待定

高阶函数

输入输出与数据持久化

类