python 常用知识点

Python 概述

• 标准库与拓展库中对象的导入与使用
  （1）import 模块名 [ as 别名 ]
  //使用时用’模块名.对象名’的形式访问
  （2）from 模块名 import 对象名 [ as 别名 ]
  //从模块中仅仅导入你想要的对象，可以直接使用对象
  （3）from 模块名 import *
  //一次导入模块中全部的对象
• _ _ name _ _ 属性: （识别程序的使用方式）
  （1）如果程序被作为模块被导入，其_ _ name _ _ 属性的值被自动设置成模块名
  （2）如果作为程序直接运行，其_ _ name _ _ 的属性的值就被自动设置成 “_ _ main _ _”

内置对象、运算符、表达式、关键字

• python 中一切都是对象，例如整数，实数，列表，元组等，zip ，map 等函数也是对象，函数和类也是对象
• 对象类型：
  （1）数字：大小没有限制，支持复数运算 （3+2j）
  （2）字符串：使用单引号，双引号，三引号作为定界符，可以嵌套，使用r或R 表示引导原始字符串
  （3）字节串： 用 字母b 引导 （b’hello’)
  （4）列表：list ，元素在方括号中，元素用逗号隔开，元素可以为任意类型
  （5）元组：tuple ，元素在圆括号中，元素用逗号隔开，只有一个元素时，逗号不能省略 (3,)
  （6）字典：dict ,元素在大括号中，按照"键：值"形式，其中键不可以重复，键必须不可变
  （7）集合：set ,所有的元素在大括号中，元素之间用逗号隔开，元素不可以重复且必须为不可变类型
  （8）布尔类型：bool ,True 或者False
• 在python 中，变量的值和类型都可以变，不需要事先声明变量名以及类型，赋值语句可以直接创建任意类型的变量（python 中变量并不直接存储值，而是存储值得内存地址或者引用）
• 变量名得命名：

（1）以字母和下划线开头
（2）变量名中不能有空格或者标点符号
（3）不能使用关键字作为变量名，不建议用系统内置得模块名等命名
（4）大小写敏感

• 对于数字类型：尽量避免实数直接比较大小，而是以绝对值来比较。为了提高可读性，可以在数字中中增加下划线，下划线可以出现在数字中间得任意位置，不能在开头和结尾，不能连续出现
• python 没有字符变量以及字符常量，就是单个字符也是字符串
• 运算符：优先级：
  算术运算符>位运算符>成员测试运算符>关系运算符>逻辑运算符

print([1,2,3] + [ 4,5])
print((1,) + (2,3))
print([1,2,3]*3)

print(15/4)
print(15.0/4)
print(15//4)
print(15//4.0)
print(-15//4)

• 取余数是向下取整
• 关系运算符：可以连用，但是操作数必须能够可以比较大小

'hello' > 3   //错误，字符串和数字不能比较大小
[1,2,3] < [1 ,2,4]  //True ,列表比较大小
{1,2}  < { 1,2,3} //True ,集合用来查看是否为子集，相等关系

• 成员测试符： in ,用于测试一个对象是否包含另一个对象

3 in [1,2,3] //True
5 in range(1,10,1)  // True
for i in(3,5,7):   //成员遍历
	print(i)

• 集合运算符：交集，并集，对称差集，集合差集：&, | ,^ , -
• 逻辑运算符： and,or,not ,(其中 and 与 or 有惰性求值和逻辑短路的特点）and 和 or 的值不一定是 True 或者False ，会把最后一个计算的表达式作为自己的值

3>5 and a>3  与 3>5 or a > 3 //前者为False ，后者会报错，a 没有被定义
3 and 5 //值为 5
3 and 5>3  //值为 True ,

• 常用内置函数：
  （1）char(x) //返回Unicode 编码的为 x 的字符
  （2）enumerate ( iterable[ , start])
  （3）input([提示]) //显示提示，接收键盘输入的内容，返回字符串
  （4）isinstance(obj,type) //检查测试对象obj 是否属于指定的类型
  isinstance(3,int) //True
  （5）len(obj) ,求对象obj 的元素的个数
  （6）list(x) ,set(x),tuple(x),dict(x) ,将x 转化为 列表，集合，元组，字典，并返回
  （7）map(func,*iterables),将迭代器对象都运用func 函数，并返回,map 函数不对原来的序列做更改

def dou ( b ):
    return b*2
a = [2,5,9,7,4]
c = map(dou,a)
print(list(c))

//双参数
def add(x,y):
    return x+y

result = map(add,range(5),range(10,15))
print(list(result))

（8）max( ),min ( ) ,sum()返回最大值，最小值,求和
（9）range(start,end,step) //返回range 对象，其中包含[start,end) ，步长为step 的整数，range 默认从 0 开始,step 默认为1，list(range(5)) 为[0,1,2,3,4]

# 默认有range(stop),range(start,stop),range(start,stop,step)
print(list(range(10)))
print(list(range(5,10)))
print(list(range(2,10,2)))

（10）reversed(seq) //返回seq 中全部元素逆序的迭代器对象
（11）sorted(iterable,key=None,reverse = False) //返回排序后的列表，iterable 是相应的对象，key 为排序规则， reverse 用来指定升序还是降序）（False 是升序排序，True 是降序排序）
（12）str(obj) //将obj 对象直接转换成字符串
（13）type(obj) //返回类型
（14）zip(seq1,seq2 ···) //返回zip 对象，其中的元素为每一个对象的交替出现(相应位置的元素压缩在一起），结果是一个相对应元素的元组，长度取决于最短的那个对象

a = ['a','b','c','d']
b = [1,2,3,4,5]
c = zip(a,b)
print(list(c))
print(list(c)) //得到的迭代器对象只能使用一次，
//迭代器 c 的内部状态已经到达了末尾

a = [0,1,2,3,4,5,6]
print(list(zip(a)))
//每一个元素得元组 [(0, )  ,(1,),(2,),(3,)(4,),(5,),(6,)]

（15）filter(func,seq) //返回filter 对象，其中包含序列seq 中使得 func 函数为True 的那些元素，如果func 为none ,则返回seq 中等价于True 的元素

def cpy (a):
    return a>5
//筛选数字
num = [1,5,9,7,3,6]
result = filter(cpy,num)
print(list(result))

（16）eval(s) //计算字符串s 的表达式的值，并返回结果

• 基本的输入输出：input / print ,不论输入什么，input() 一律作为字符串，必要时可以使用 内置函数 int(),float()或者eval()对输入进行转换
• print(value1,value2,····valuen,sep=" ",end = ‘\n’)
  sep指定每个元素的分隔符，默认为空格，end 为最后的操作，默认情况下为换行）

• 排序和逆序：sorted 的key 值可以用lambda 表达式 ，reversed()翻转
• 枚举和迭代：enumerate()函数可以用来枚举可迭代的对象中的元素，返回可迭代的enumerate对象，其中每一个元素都是包含索引和值的元组，可以将enumerate 对象直接转换成 列表、元组、集合，也可以使用for 循环直接遍历其中元素

print(list(enumerate('abcd')))

print(list(enumerate(["abc","bcd"])))

for index,value in enumerate(range(10,15)):
    print((index,value),end=" ")

• reduce() 函数将一个接收两个参数的函数以迭代累计的方式从左到右依次作用到一个序列的全部元素上，并且允许指定一个初始值

from functools import reduce
//计算阶乘 （（（（（1*2）*3）*4）*5）
result = reduce(lambda x,y:x*y ,range(1,6));
print(result)

• 注意，enumerate ,map,filter ,zip 函数返回的迭代器对象只能使用一次，访问过后就不存在了

Python 序列结构

• 列表：数据收纳盒。列表里面的元素可以互不相同，可以同时包含整数、实数、字符串等，也可以包含列表、元组等

# 字符串改成列表
print(list('anbcdj'))
# 元组变成列表
print(list((1,2,3,4)))
# 字典的键变成列表
print(list({'a':11,'nihao':12,'asd':13}))
# 字典的元素变成列表
print(list({'a':11,'nihao':12,'asd':13}.items()))

• 列表的删除 用 del
• 列表元素的访问：正向索引，0表示最后一个元素，反向索引，-1表示最后一个元素

a = [0,1,2,3,4,5,6]
print(a[6])
print(a[-1])
# 都是输出6

• 列表常用方法：
  （1）append(x) //将x 追加至列表的尾部
  （2）extend(L) //将列表L 中的全部的元素追加至 列表的尾部
  （3）insert(index,x) //在列表的 index 处插入 x
  （4）remove(x) //删除列表的第一个元素，当第一个元素不存在就抛出异常
  （5）pop(index) //删除并返回列表中下标为index 的元素
  （6）index(x) //返回列表第一个元素的索引
  （7）count(x) //返回 元素x 在列表中出现的次数
  （8）reverse() //对列表的全部元素进行原地逆序
  （9）sort(key = None, reverse=False) //对列表的元素进行原地排序，key 用来指定排序规则， reverse = False 表示升序，True 表示降序）
  区别于内置函数sorted(iterable,key,reverse)

a = [0,1,2,3,4,5,6]
b = sorted(a,reverse=True)
print(b)
a.sort(key=None,reverse=True)
print(a)
# sorted 是返回一个排序的对象，但是sort 是在自身的基础上排序

• 列表的内存有自动收缩和扩张的功能，在列表中插入和删除元素，会导致下标的对应得变化

• 列表推导式：可以快速使用简洁的方法对列表以及其他可以迭代的对象的元素进行遍历，过滤，或者再次计算，快速生成满足需求的新的列表(在逻辑上相当于一个循环语句）

[expression for expr1 in sequence1 if condition 1
					 for expr2 in sequence2 if condition 2
·····
					for exprN in sequenceN if condition N
]

a = [x+x for x in range(20) if x % 2 ==0]
print(a)
# [0, 4, 8, 12, 16, 20, 24, 28, 32, 36]

a = [[1,2,3],[4,5,6]]
b = [num for elem in a for num in elem] //如何理解? 从正常的两重循环的角度去看即可
print(b)
# [1, 2, 3, 4, 5, 6]

a = [1,2,3,4]
b = [4,5,6]
c= [(x,y) for x in a for y in b]
print(c)
c= [(x,y) for x in a if x ==2 for y in b]
print(c)

#[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6)]
#[(2, 4), (2, 5), (2, 6)]

• 切片：[start : end : step]
start 是切片开始的位置 ， end 是切片结束的位置，step 是切片的步长 ， 其中 [ start ,end )不包含 end ,start 默认值为 0 ，end 默认值为列表的长度，step 的默认值为1 ，与 range 的用法极为相似
切片不会因为超出列表的边界而抛出异常，而是简单的在末尾截断
• [ : : ] 返回原来的列表，[ : : -1] 返回逆序列表
• 使用切片为列表增加元素

a = [1,2,3]
a[len(a):] = [9]  # 表尾插入
print(a)
a[:0] = [0]  # 表头插入
print(a)
a[2:2] = [88]  # 中间插入
print(a)

# 列表的插入也同理
a = [1,2,3]
a[:1] = [4,5,6]
//a 变成 [4,5,6,2,3]
//要是想删除的话，就赋值为[ ]

• 元组：元组可以看成列表的简化版，元组也支持双向索引，支持通过下标来访问特定的元素tuple
• 元组与列表的异同点：都是有序序列，但是元组属于不可变序列，无法修改元组的内容，只能通过切片来访问元素，列表可以修改，元组可以作为字典的键，也可以作为集合的元素（不可变），但是列表不行
• 生成器表达式：与列表推导式类似，但是生成器对象的结果是一个生成器对象，具有惰性求值的特点。形式上，是列表推导式的中括号换成圆括号
• 生成器对象的遍历：可以用生成器对象的 _ _ next _ _ 或者 next() 遍历以及for 循环直接遍历，只能从前往后遍历，没有办法再次访问访问过的元素，不支持下标来访问（童enumerate 、 filter 、 map 、 zip 等迭代器的对象）

• 字典：一种无序可变序列。键为不可变元素，键不可以重复，值可以重复