Python基础知识点总结

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 l
  l = [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 s
  s = "This is a test"
  print(check(s))
  print(s)
  ​
  '''
  This is a test
  2418424029424
  2418424029488
  i am test
  This 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 key
  key.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 sys
  dir(sys.modules['__builin__'])

内置函数表;

		内置函数
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	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 = x
  x = y
  y = temp
  # 3、异或
  # 规律：一个数异或另一个数两次之后的结果为该数本身
  x = x ^ y
  y = x ^ y
  x = x ^ y
  # 4、加减法
  x = x + y
  y = x - y
  x = x - y

2.4.3成员及身份运算：

成员运算符：in、 not in

身份运算符：is、is not

2.5Python 中的语句

2.5.1if语句

if语句在Python中的两种结构为：

  # 1
  if 条件表达式：
      代码块
  ​
  # 2
  if 条件表达式：
      代码块
  elif 条件表达式：
      代码块
    
  # 3
  if 条件表达式：
      代码块
  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 += 1

break：直接跳出当前循环

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<i或者说s[i,-1]倒着取

  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()))   #<class 'dict_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	空
\n	换行
\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 格式化操作符辅助指令表

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零('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()	复制列表