Python基础知识的总结
小编给大家分享一下Python基础知识的总结，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：主机域名、虚拟主机、营销软件、网站建设、德清网站维护、网站推广。
Python基础知识：1、引用和对象；2、可变数据类型和不可变数据类型；3、引用传递和值传递；4、深拷贝和浅拷贝；5、基本数据类型；6、关键字、标识符和内置函数；7、算术、赋值运算符等等。
Python基础知识总结
一、Python概述：
1.1、Python的特点：
1、Python是一门面向对象的语言，在Python中一切皆对象
2、Python是一门解释性语言
3、Python是一门交互式语言，即其在终端中进行命令编程
4、Python是一门跨平台的语言【没有操作系统的限制，在任何操作系统上都可以运行Python代码】
5、Python拥有强大和丰富的库，又被称为胶水语言，能把其他语言（主要c/c++）写的模块很轻松的结合在一起
1.2、Python的优缺点：
1、优点：
a、易于维护和学习
b、广泛的标准库【提供了大量的工具】
c、可扩展性
d、Python对于大多数据库都有相应的接口【MySQL、sqlites3、MongoDB、redis等】
e、支持GUI编程【图形化界面】
f、语法简单，易于学习
2、缺点：
a、和C语言相比较Python的代码运行速度慢
b、代码无法加密
1.3、Python代码的执行过程：
大致流程：源码编译为字节码（.pyc)----->Python虚拟机------->执行编译好的字节码----->Python虚拟机将字节码翻译成相对应的机器指令（机器码）。
Python程序运行时，先编译字节码并保存到内存中，当程序运行结束后，Python解释器将内存中的字节码对象写到.pyc文件中。
第二次再运行时，先从硬盘中寻找.pyc文件，如果找到，则直接载入，否则重复上面过程。
优点：不重复编译，提高执行效率
二、Python中的基础语法：
2.1、Python中变量在内存中的存储
2.1.1引用和对象：
对象：当创建数据对象时，在内存中会保存对象的值，这个值就是对象自己；
引用：对象保存在内存空间，外部想要使用对象的值，就需要使用引用来操作对象。内存中会保存对象引用的数量，当某个对象的引用为0时，对象会被回收。
2.1.2可变数据类型和不可变数据类型
a、数据分类：
可变数据对象：列表（list）和字典（dict）
不可变数据对象：整型（int）、浮点型（float）、字符串（string）和元组类型（tuple）
注：此处的可变和不可变，是指内存中的对象（Value）是否可以改变，对于不可变类型的对象，在对对象操作的时候，必须在内存中重新申请一块新的区域，即重新给一个新的地址用于存储；对于可变类型的对象，在对对象操作的时候，并不会重新申请新的地址，而是在该对象的地址后面继续申请即可，即address并不会改变，而是address的区域的大小会变长或变短。
不可变数据类型：对象本身的值不可变，如果改变了变量的值，相当于新建了一个对象，而对于相同值的对象，在内存中只有一个对象。
可变数据类型：允许变量的值进行改变，对于变量给值的过程中，只是改变了变量的值，而不会新建一个对象，所以可变数据类型的意思就是说对一个变量进行操作时，其值是可变的，值的变化并不会引起新建对象，即地址是不会变的，只是地址中的内容变化了或者地址得到了扩充。，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
2.1.3引用传递和值传递（函数传值）
说明：可变对象为引用传递，不可变对象为值传递
引用传递：传递列表或者字典时，如果改变引用的值，就修改了原始的对象
def check(l): print(l) print(id(l)) l.append([1, 23, 2, 3, 4]) return ll = [1, 2, 3, 4]print(check(l))print(id(l))'''[1, 2, 3, 4]2902500909320[1, 2, 3, 4, [1, 23, 2, 3, 4]]2902500909320'''
值传递：当传递不可变对象时，如果改变引用变量的值，只是创建了不同的对象，原始对象并没有改变。
def check(s): print(s) print(id(s)) s = "i am test" print(id(s)) return ss = "This is a test"print(check(s))print(s)'''This is a test24184240294242418424029488i am testThis is a test'''
2.1.4深拷贝和浅拷贝
浅拷贝：语法：copy.copy()，浅拷贝是创建了一个和原对象一样的类型，但是其内容是对原对象元素的引用。
深拷贝：语法：copy.deepcopy(),在内存中将所有的数据重新建立一份。
变量的本质：在内存中开辟了一块空间，其中存储了指定类型的数据【实体（对象）存储在堆中，变量（引用）存储在栈空间中
2.2基本数据类型
Python中常用的数据类型有：整型（int）、浮点型（float）、字符串（string）、空值（None）、布尔值（True和False）、复数、类、函数等
Python中常量的命名规则使用变量名为全大写为常量
变量的命名遵循标识符的命名规则
2.3关键字、标识符和内置函数
1、关键字：在Python中被赋予了特殊含义的英文单词
Python中的关键字的查看使用keyword模块
import keyword as keykey.kwlist'''['False','None','True','and','as','assert','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']'''
2、标识符的命名规则：标识符的命名构成：数字、字母、下划线，但不能以数字开头，在标识符的命名中严格区分大小写
命名规范：
Python官方：所有单词全部小写，不同单词之间使用下划线分割，普遍是用驼峰命名法（小驼峰与大驼峰）
3、内置函数：
import sysdir(sys.modules['__builin__'])
内置函数表;
| 内置函数 | ||||
|---|---|---|---|---|
| abs() | dict() | help() | min() | setattr() |
| all() | dir() | hex() | next() | slice() |
| any() | pmod() | id() | object() | sorted() |
| ascii() | enumerate() | input() | oct() | staticmethod() |
| bin() | eval() | int() | open() | str() |
| bool() | exec() | isinstance() | ord() | sum() |
| bytearray() | filter() | issubclass() | pow() | super() |
| bytes() | float() | iter() | print() | tuple() |
| callable() | format() | len() | property() | type() |
| chr() | frozenset() | list() | range() | vars() |
| classmethod() | getattr() | locals() | repr() | zip() |
| compile() | globals() | map() | reversed() | import() |
| complex() | hasattr() | max() | round() | |
| delattr() | hash() | memoryview() | set() |
2.4Python运算符
2.4.1算术、赋值运算符：
**：求幂运算
//：整除运算或者成为地板除
%：取余运算
常用算数运算符的优先级：** > * > / // % > + -
赋值运算符：=
复合运算符：+=、-= 、*= 、/=
关系比较：==、!=、>=、<=等
2.4.2逻辑运算
| 运算符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。【 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
| 算符 | 描述 |
|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1。（运算原理：计算补码，按位取反，转为原码，末尾加1） |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 |
# 位运算实例：x与y的数值的交换# 1、交叉赋值x, y = y, x# 2、第三方变量temp = xx = yy = temp# 3、异或# 规律：一个数异或另一个数两次之后的结果为该数本身x = x ^ yy = x ^ yx = x ^ y# 4、加减法x = x + yy = x - yx = x - y
2.4.3成员及身份运算：
成员运算符：in、 not in
身份运算符：is、is not
2.5Python 中的语句
2.5.1if语句
if语句在Python中的两种结构为：
# 1if 条件表达式： 代码块# 2if 条件表达式： 代码块elif 条件表达式： 代码块 # 3if 条件表达式： 代码块else： 代码块
2.5.2for语句
for 变量 in 数据结构： 循环体
# 9*9乘法表for i in range(1,10): for j in range(1,i + 1): print("%dx%d=%d" % (j,i,i * j),end=" ") print("")2.5.3while语句
while 条件表达式： 代码块
# 9*9乘法表
while line < 10:
temp = 1
while temp <= line:
print("%d x %d = %d"%(temp, line, temp*line),end = " ")
temp += 1
print("")
line += 1break：直接跳出当前循环
continue：结束当前正在执行的循环，继续下一次循环
三、Python内置数据结构：
Python中最基本的数据结构是序列（sequence），Python包含 6 中内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。
3.1、String
3.1.1、字符串的创建
将文本放在单引号，双引号和三引号之间
>>> str1 = ' hello, fanison ' >>> type(str1) str
3.1.2、字符串的转义：
字符串的转义使用r
3.1.3、字符串的切片操作
索引运算符 s[i] 返回一个序列的元素i
切片运算符 s[i:j] 返回一个在字符串中从第i个元素开始到j-1之间的元素
扩展切片运算符 s[i:j:step] 在字符串中以step的步长从第i个到j-1个元素之间的元素，step为正数表示正着取，i
len(s) s中的元素个数
min(s) s的最小值
max(s) s的最大值
3.1.4字符串的相关方法：
s.index(sub [,start [,end]]) 找到指定字符串sub首次出现的位置
s.find(str,beg=0,end=len(string)) 找到字符串sub首次出现位置，与index不同是不报错而返回-1
s.upper() 将一个字符串转换为大写形式
s.lower() 将一个字符串转化为小写形式
s.join(t) 使用s作为分隔符连接序列t中的字符串 s.strip() 将s两边不显示的符号去掉之后返回（lstrip、rstrip）
s.split(t) 获取以字符t将s切割的列表
s.encode() 获取s的指定编码的bytes值
bytes.decode() 获取bytes的对应编码的字符串，在python2中使用decode函数
s.endswith(suffix,beg=0, end=len(string)) 检查中是否以suffix字符串结尾
3.2list
变量：相当于是一个容器，每次只能存储一个数据
作用：相当于是一个容器，可以同时存储多个数据
本质：一种有序的集合【有序：数据的存放顺序和底层存储的顺序是相同】
列表中的元素本质存储的是一个变量【引用】，列表是可变的【一个列表一旦被定义，则在代码运行的过程中，其中的元素的值可以随时发生改变】
num = 10
list1 = [43,5,45,46,5]
print(id(list1[0]))
list1[0] = 100
#1.创建【定义一个列表类型的变量】 #命名方式：lxx listxxx,不建议直接使用list #其中允许存放重复元素 list1 = [45,23,2,54,54,6] print(list1) #其中允许存放不同类型的数据 list2 = ["hello",4637,False] print(list2) #列表元素的访问 #索引/下标/角标：取值范围：0~len(xx) - 1 或者 -1~ - （len(xxx)） print(list1[3]) print(list1[-1]) #print(list1[20]) #IndexError: list index out of range 列表下标越界 #列表元素的替换/修改 list1[3] = 473 print(list1) #组合:生成了一个新的列表 print(list1 + list2) print(list1) #列表元素的重复 print(list1 * 3) print(list1) #判断某个元素是否在列表中 print(10 in list1) #False print(10 not in list1) #True print(45 in list1) #True print(45 not in list1) #False #列表切片【截取】：根据指定的列表获取子列表 list3 = [45, 23, 2, 473, 54, 6,5,6,56,5] print(list3[2]) print(list3) #格式：列表名[start：end：step]，包头不包尾 #获取从指定下标开始到结尾的元素组成的一个子列表 print(list3[2:]) #获取从开头到指定下标的元素。。。。 print(list3[:6]) #截取指定区间 print(list3[2:6]) #特殊情况1：如果end超出了下标的范围，则默认获取从指定下标开始到结尾的元素 print(list3[4:100]) #等价于 print(list3[4:]) #特殊情况2：step在默认情况下为1 print(list3[1:6:2]) #1,3,5 print(list3[-1:-6]) #当start和end都为负数，step为正数的时候，获取的结果为[] print(list3[-1:-6:-2]) #当start，end和step都为负数的时候，表示倒序 #将列表倒序输出 print(list3[-1::-1]) print(list3[::-1]) #列表系统功能 #1.添加元素 #1.1append，追加，在列表的末尾添加元素 常用 l1 = [22,33,44,55] print(l1) #追加单个元素 l1.append(66) print(l1) #追加多个元素，不能直接追加，通过列表的形式追加，形成了一个二维列表 #l1.append(77,88) #报错：TypeError: append() takes exactly one argument (2 given) l1.append([77,88]) print(l1) #结果：[22, 33, 44, 55, 66, [77, 88]] #1.2extend，扩展，在列表的末尾添加元素 l2 = [22,33,44,55] #追加单个元素,不能直接添加，参数一定是可迭代的 #l2.extend(66) #T报错：ypeError: 'int' object is not iterable l2.extend([66]) print(l2) l2.extend([77,88]) print(l2) #结果：[22, 33, 44, 55, 66, 77, 88] """ 总结： 列表名.功能名(xx) append可以直接添加单个元素，而extend不能 append在添加多个元素的时候，是以列表的形式添加，而extend只添加元素【打碎加入】 """ #1.3insert，插入，在指定索引处插入一个元素，后面的元素向后顺延 #列表名.insert(索引，被插入的元素) l3 = [22,33,44,55] #插入单个元素 l3.insert(2,66) print(l3) #插入多个元素:和append类似，将整个列表直接插入 l3.insert(1,[77,88]) print(l3)#2.删除 #2.1pop,弹出,移除并获取列表中指定索引处的元素 在栈中【列表的底层工作原理是栈】 list1 = [11,22,33,44,55] #注意：pop在默认情况下删除的是最后一个元素 result1 = list1.pop() print(list1) print(result1) result2 = list1.pop(2) print(list1) #2.2remove，移除，直接操作的是元素 list2 = [11,22,33,44,55,33,33,55] list2.remove(22) print(list2) #注意：移除指定元素在列表中第一次匹配到的元素【从左往右】 list2.remove(33) print(list2) #2.3clear 清除，将指定列表变为空列表 使用场景：循环中，每次需要清空【重置】列表 list2.clear() print(list2)#3.获取 list1 = [54,6,57,5,57,7,6,7,57] #3.1len(),获取列表长度 l = len(list1) #3.2max(),获取列表中的最大值 print(max(list1)) #3.3min()，获取列表中的最小值 print(min(list1)) #练习：模拟max或者min的功能，求三个数中的最大值 #假设法 num1 = 43 num2 = 437 num3 = 2 #定义一个变量，用于记录最大值 max1 = num1 if num2 > num1: max1 = num2 if num3 > max1: max1 = num3 #3.4index()，获取指定元素在原列表中第一次匹配到的索引 print(list1.index(57)) #模拟index的功能 for i in range(len(list1)): if list1[i] == 57: print(i) #3.5count(),统计个数，统计指定元素在列表中出现的次数 c = list1.count(57) print(c) list1 = [54,6,57,5,57,7,6,7,57,57,57,436] #练习：将list1中57给全部删除 # list1.remove(57) # list1.remove(57) # list1.remove(57) # print(list1) #统计57在列表中出现的次数 num = 57 c = list1.count(num) n = 1 while n <= c: list1.remove(num) n += 1 print(list1)import copy #4.其他用法 #4.1.reverse,反转 list1 = [35,4,5,4,654] #print(list1[::-1]) # list1.reverse() # print(list1) #4.2.1sort,排序,默认为升序,在列表内部进行排序 #列表名.sort() #升序 # list1.sort() # print(list1) #降序 # list1.sort(reverse=True) # print(list1) #4.2.2sorted，排序,默认为升序，生成了一个新的列表 #sorted(列表名) #升序 newList = sorted(list1) print(list1) print(newList) #降序 newList2 = sorted(list1,reverse=True) print(newList2) #根据元素的长度进行排序 list2 = ["gjsrghj","545","fhghg","ahjegrhkwjhgrke"] #key关键字参数可以指定自定义的排序规则,格式：key=函数名 newList3 = sorted(list2,key=len,reverse=True) print(newList3) #4.3copy,拷贝 #直接赋值，浅拷贝，栈空间层面上的拷贝【引用】 list1 = [23,54,56] list2 = list1 list2[1] = 100 print(list1) print(list2) print(id(list1) == id(list2)) #copy，深拷贝，堆空间层面上的拷贝【实体】 list1 = [23,54,56] list2 = list1.copy() list2[1] = 100 print(list1) print(list2) print(id(list1) == id(list2)) #模块copy ，copy(),deeepcopy()【面试题】 #内容角度上的拷贝，copy只拷贝最外层，deepcopy可以拷贝内层的内容【二维列表中】 a = [1,2,3] b = [4,5,6] c = [a,b] print(c) d = copy.copy(c) print(id(d) == id(c)) #False e = copy.deepcopy(c) print(id(e) == id(c)) #False a.append(4) print(c) print(d) #[[1, 2, 3, 4], [4, 5, 6]] print(e) #[[1, 2, 3], [4, 5, 6]] """ d:[[1, 2, 3], [4, 5, 6]] [list1,list2]---->list1:[1,2,3] list2:[4,5,6] """ #4.4转换 #list(),tuple() #二维列表：遍历 l1 = [[11, 22, 33, 44], [44, 55, 66]] print(l1[0]) #l1[0] = [11, 22, 33, 44] print(l1[0][2]) for i in l1: for j in i: print(j) for n1 in range(len(l1)): for n2 in range(len(l1[n1])): print(l1[n1][n2])
3.3tuple
和列表类似，本质是一种有序的集合
元组和列表的不同之处：
a.定义不同：列表[] 元组()
b.是否能够修改：列表可以进行增加或者删除元素的操作，但是，元组一旦被定义之后，其中的元素将不能进行任何的更改
#其中允许存储重复元素 t1 = (23,53,54,53) print(t1) #其中允许存储不同类型的数据 t2 = ("hello",47,19.0,False) print(t2) #特殊情况:当一个元组中只有一个元素的之后，会被识别为一个普通变量 t3 = (10) print(type(t3)) print(t3) #为了消除歧义，当元组中只有一个元素的时候，元组名 = (元素,) t4 = (10,) print(type(t4)) print(t4) #元组元素的访问 #元组名[索引] print(t2[1]) #t2[1] = 100 #报错：TypeError: 'tuple' object does not support item assignment【赋值】 #特殊情况：如果在元组中的元素是列表，则列表中的元素依旧可以修改 # 【依据：元组和列表中存储都是变量的地址，元素不允许修改，只需要保证未发生改变即可其中的地址】 t5 = (23,5,3,5,[235,345,5,45,4]) print(t5) print(t5[4]) #[235,345,5,45,4] t5[4][1] = 100 print(t5) #列表和元组的遍历 #直接获取元素 for element in t5: print(element) #获取索引 for i in range(len(t5)): print(i,t5[i]) #同时遍历索引和元素 #需要将元组或者列表转换为枚举类型 #list(t5) #注意：下面的i并不是元组或者列表的索引，而是枚举中的编号 for i,element in enumerate(t5): print(i,element)
3.4dict 常用
也是一种存储数据的方式，但是字典是无序的，
类似于list或者tuple，但是，字典采用键-值对的方式存储数据
age1 = 10 list1 = [10,4,35,46,6] dict1 = {"zhangsan":10}作用：具有极快的查找速度
键【key】相当于list或者tuple中的索引
key的特点
a.字典的key是唯一的【key不允许重复】
b.key必须为不可变的数据
list是可变的，不能用来当做key
tuple，数字型，字符串，布尔值都是不可变的，可以被充当key
dict1 = {"zhangsan":10,"lisi":13,"zhaoliu":50} #1.访问键值对 print(dict1["lisi"]) #访问一个不存在的key，则报错 #print(dict1["abc"]) #KeyError: 'abc' #字典是可变的 dict1["zhaoliu"] = 100 result0 = dict1["zhaoliu"] print(result0) #字典名[key] = value #注意：如果key存在，则表示修改value的值；如果key不存在，则表示在字典中添加一对新的键值对 dict1["abc"] = 20 print(dict1) #get() result1 = dict1.get("zhaoliu") print(result1) #如果key不存在，则不会报错，返回None，一般用于判断 result2 = dict1.get("def") print(result2) #2.删除，pop #注意：删除指定的key，对应的value也会随着删除 dict1.pop("lisi") print(dict1) #3.字典的遍历 #3.1直接遍历key 掌握 for key in dict1: print(key,dict1[key]) # print(dict1.keys()) # print(type(dict1.keys())) #for key in dict1.keys(): print(key,dict1[key]) #3.2直接遍历value for value in dict1.values(): print(value) #3.3,遍历的是键值对的编号和key for i,element in enumerate(dict1): print(i,element) #3.4同时遍历key和value 掌握 for key,value in dict1.items(): print(key,value) """ 【面试题：dict和list之间的区别】 1.dict查找和插入的速度不会因为key-value的增多而变慢， 而list在每次查找的时候都是从头到尾进行遍历，当数据量大的时候，list速度肯定会变慢 2.dict需要占用大量的内存空间，内存浪费多， 而list只相当于存储了字典中的key或者value，并且list数据是紧密排列的 """ 练习：
"""" 1.逐一显示列表l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]中索引为奇数的元素 2.将属于列表l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]， 但不属于列表l2 = ["Sun","Mon","Thu","Fri","Sat"]的所有元素定义为一个新列表l3 3.已知列表namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7']，删除列表removelist=['stu3', 'stu7', 'stu9']； 请将属于removelist列表中的每个元素从namelist中移除(属于removelist，但不属于namelist的忽略即可)； 4.有一个字符串是一句英文，统计每个单词出现的次数，生成一个字典，单词作为key，次数作为value生成一个字典dict1 5.已知列表list1 = [0,1,2,3,4,5,6],list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"], 以list1中的元素作为key，list2中的元素作为value生成一个字典dict2 """ #1. l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"] for i in range(len(l1)): if i % 2 != 0: print(l1[i]) #2. #思路：遍历l1,获取l1中的元素，判断在l2中是否存在，如果不存在，则添加到一个新的列表中 l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"] l2 = ["Sun","Mon","Thu","Fri","Sat"] l3 = [] for ele1 in l1: if ele1 not in l2: l3.append(ele1) #3 #思路：遍历removelist,获取其中的元素，判断该元素在namelist中是否存在，如果存在，则删除 namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7'] removelist=['stu3', 'stu7', 'stu9'] for ele2 in removelist: if ele2 in namelist: namelist.remove(ele2) print(namelist) #4 str1 = "today is a good day today is a bad day today is a nice day" dict1 = {} #使用空格切割字符串 list1 = str1.split(" ") print(list1) #遍历列表，获取其中的每个单词 for word in list1: #在字典中通过key获取value c = dict1.get(word) if c == None: #不存在，添加键值对 dict1[word] = 1 else: #存在，则将value的值递增1 dict1[word] += 1 print(dict1) #5. list1 = [0,1,2,3,4,5,6] list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"] dict2 = {} #定义一个变量，作为list1和list2的索引 index1 = 0 if len(list1) == len(list2): while index1 < len(list1): #dict2[key] = value =======>dict2[list1中的元素] = list2中的元素 #list1[index1] list2[index1] dict2[list1[index1]] = list2[index1] index1 += 1 elif len(list1) > len(list2): while index1 < len(list2): dict2[list1[index1]] = list2[index1] index1 += 1 else: while index1 < len(list1): dict2[list1[index1]] = list2[index1] index1 += 1 # 优化上面的代码：封装【抽取】 """ def custom(num): dict2[list1[num]] = list2[num] num += 1 return num #定义一个变量，作为list1和list2的索引 index1 = 0 if len(list1) == len(list2): while index1 < len(list1): #dict2[key] = value =======>dict2[list1中的元素] = list2中的元素 #list1[index1] list2[index1] r = custom(index1) index1 = r elif len(list1) > len(list2): while index1 < len(list2): r = custom(index1) index1 = r else: while index1 < len(list1): r = custom(index1) index1 = r """ print(dict2)
3.4set
集合：不允许重复元素，而且进行交集以及并集的运算
表示：{}
和dict之间的关系：set中只是存储了key
本质：无序且无重复元素的集合
#1.创建 #set() s1 = {23,45,6,7,89} print(s1) print(type(s1)) #掌握：去除列表中的重复元素 s2 = set([3,46,5,65,7,65,7]) print(s2) s3 = set((2,43,54,5,4,5)) print(s3) s4 = set({10:"a",20:"b"}) print(s4) #2.set是可变的 #2.1添加 #add(),添加， set1 = {11,22,33,44,55} #单个元素 set1.add(66) print(set1) #如果元素存在，则添加失败，不报错 set1.add(55) #多个元素 #s1.add([77,88]) #TypeError: unhashable type: 'list' s1.add((77,88)) #s1.add({1:"a"}) #结论：在set中，使用add添加，则只能添加元组，不能添加list和dict print(s1) #update()，更新,update的参数只能是可迭代对象【打碎加入】 set2 = {11,22,33,44,55} #set2.update(66) #报错：TypeError: 'int' object is not iterable set2.update([66]) print(set2) set2.update((77,88)) print(set2) set2.update({"12":12,"13":13}) print(set2) set2.update("hgjhg") print(set2) #3.删除 set2.remove(77) print(set2) #4.交集和并集 s1 = {3,54,4,5,7} s2 = {3,54,4,8,90} #交集：&【按位与】 print(s1 & s2) #并集：|【按位或】 print(s1 | s2)
list、tuple、dict、set的区别和联系：
a、定义方式：list：[]、tuple：（）、dict：{}、set：{}
b、是否有序：list:有序，tuple：有序，dict：无序，set：无序
c、是否允许出现重复元素：list：允许，tuple：允许，dict：key键值不允许，但是value的值允许，set：不允许
d、都属于可迭代对象
e、set相当于存储了字典中的key
f、可以向互转化
4、附录
4.1 字符串转义字符表
在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：
| 转义字符 | 描述 |
|---|---|
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| 换行 | |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
4.2 python字符串格式化符号表
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
4.3 格式化操作符辅助指令表
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| 在正数前面显示空格 | |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
4.4 字符串内建方法表
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | capitalize() | 将字符串的第一个字符转换为大写 |
| 2 | center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| **4 | bytes.decode(encoding="utf-8", errors="strict") | Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| **5 | encode(encoding='UTF-8',errors='strict') | 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
| **6 | endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| 7 | expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| **8 | find(str, beg=0 end=len(string)) | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) | 跟find()方法一样，只不过如果str不在字符串中会报一个异常. |
| 10 | isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
| 11 | isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| 12 | isdigit() | 如果字符串只包含数字则返回 True 否则返回 False.. |
| 13 | islower() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric() | 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
| 16 | istitle() | 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper() | 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| **18 | join(seq) | 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| *19 | len(string) | 返回字符串长度 |
| 20 | ljust(width[, fillchar]) | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | lower() | 转换字符串中所有大写字符为小写. |
| 22 | lstrip() | 截掉字符串左边的空格或指定字符。 |
| **23 | maketrans() | 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| *24 | max(str) | 返回字符串 str 中最大的字母。 |
| *25 | min(str) | 返回字符串 str 中最小的字母。 |
| **26 | replace(old, new [, max]) | 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) | 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) | 类似于 index()，不过是从右边开始. |
| 29 | rjust(width,[, fillchar]) | 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | rstrip() | 删除字符串字符串末尾的空格. |
| **31 | split(str="", num=string.count(str)) | num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串 |
| **32 | splitlines([keepends]) | 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| **33 | startswith(str, beg=0,end=len(string)) | 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| **34 | strip([chars]) | 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() | 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| **37 | translate(table, deletechars="") | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper() | 转换字符串中的小写字母为大写 |
| 39 | zfill (width) | 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal() | 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
备注：*标记为相关内建函数，**标记为常用方法。
4.5 Python列表函数&方法
Python包含以下函数:
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | [len(list) | 列表元素个数 |
| 2 | [max(list) | 返回列表元素最大值 |
| 3 | [min(list) | 返回列表元素最小值 |
| 4 | [list(seq) | 将元组转换为列表 |
Python包含以下方法:
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | list.append(obj) | 在列表末尾添加新的对象 |
| 2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) | 将对象插入列表 |
| 6 | list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() | 反向列表中元素 |
| 9 | list.sort(cmp=None, key=None, reverse=False) | 对原列表进行排序 |
| 10 | list.clear() | 清空列表 |
| 11 | list.copy() | 复制列表 |
以上是Python基础知识的总结的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！
当前名称：Python基础知识的总结
网页链接：http://cdiso.cn/article/jsphid.html
