四Python数据类型和运算符（非常详细）

一保留字与标识符

1Python保留字

指在Python中被赋予特定意义的一些单词，在开发程序时，不可以把这些保留字作为变量、函数、类、模块和其他对象的名称来使用

保留字严格区分大小写

查询python中的保留字

# coding=utf-8
import keyword
print(keyword.kwlist) #列出保留字
print(len(keyword.kwlist))   #获取保留字的个数

#执行脚本可以得到
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']
35

保留字严格区分大小写

true='真'
True=‘真’ #Trues Python中的保留字，不能用作变量名字，会报错

2Python标识符

自己在写代码的时候给一些变量或者函数等起的名字 Python标识符的命名规则

• 可以是字符（英文、中文）、下划线“_”和数字，并且第一个字符不能是数字
• 不能使用Python中的保留字
• 标识符严格区分大小写
• 以下划线开头的标识符有特殊意义，一般应避免使用相似的标识符
• 允许使用中文作为标识符，但不建议使用

Python标识符的命名规范

• 模块名尽量短小，并且全部使用小写字母，可以使用下划线分隔多个字母。例如：grame_main
• 包名尽量短小，并且全部使用小写字母，不推荐使用下划线。例如：com.ysjpython ，不推荐使用com_ysjpython
• 类名采用单词首字母大写形式(Pascal风格)。例如：MyClass
• 模块内部的类采用“_”+Pascal 风格的类名组成，例如:在MyClass中的内部类_InnerMyClass
• 函数、类的属性和方法的命名，全部使用小写字母，多个字母之间使用下划线分隔
• 常量命名时采用全部大写字母，可以使用下划线
• 使用单下划线“_”开头的模块变量或函数是受保护的，在使用“from xxx import *”语句从模块中导入时，这些模块变量或函数不能被导入
• 使用双下划线“__”开头的实例变量或方法是类私有的
• 以双下划线开头和结尾的是Python的专用标识，例如：init()表示初始化函数

二变量与常量

1变量

(1)变量的语法结构 变量名=value 举例：luck_number=8

#coding=utf-8
#变量的定义与使用
luck_number=8  #创建一个整型变量luck_number，并为其复制为8
my_name='Sally' #字符串类型的变量

print('luck_number的数据类型是:',type(luck_number))
print('my_name的数据类型是:',type(my_name))

print(my_name,'的幸运数字是:',luck_number)

#python动态修改变量的数据类型，通过赋不同类型的值就可以直接修改
print('luck_number的数据类型是:',type(luck_number))

#在Python中允许多个变量指向同一个值
no=number=1024 #no与number都指向了1024这个整数值
print(no,number)
print(id(no))  #id()查看对线的内存地址
print(id(number))



#运行得到
luck_number的数据类型是: <class 'int'>
my_name的数据类型是: <class 'str'>
Sally 的幸运数字是: 8
luck_number的数据类型是: <class 'int'>
1024 1024
2006962453968
2006962453968

(2)变量命名应遵循以下几条规则 变量名必须是一个有效的标识符 变量名不能使用Python中的保留字 慎用小写字母l（挨）和大写字母O 应选择有意义的单词作为变量名

2常量

常量就是在程序运行过程中， 值不允许改变的量 全部使用大写字母和下划线命名

#常量的定义
pi=3.1415926 #定义了一个变量
PI=3.1415926 #定义了一个常量，常量就不要尝试去修改它了

三Python中基本数据类型

1整数类型

整数类型表示的数值是没有小数部分的数值，包含正整数、负整数和0 是不可变数据类型

进制种类	引导符号	描述
十进制	无	默认情况，例如:365,786
二进制	0b或0B	由字符0和1组成，例如0b10101,0B10101
八进制	0o或0O	由字符0到7组成，例如0o763,0O765
十六进制	0x或0X	由字符0到9，a到f或A到F 组成，例如0x987A,0X987A

#coding=utf-8
num=987  #默认是十进制，表示整数
num2=0b1010101 #使用二进制表示整数
num3=0o765 #使用八进制表示整数
num4=0x87ABF  #使用十六进制表示整数

print(num)
print(num2)
print(num3)
print(num4)

#运行得到
987
85
501
555711

2浮点数类型

浮点数类型 表示带有小数点的数值，由整数部分和小数部分组成 是不可变数据类型 注意：两个浮点类型的数在进行运算时，有一定的概率运算结果后增加一些“不确定的”尾数

Python中的复数与数学中的复数形式完全一致，由实部和虚部组成

j=√−1 

在Python中实数部分使用.real表示，虚数部分使用.imag表示

#coding=utf-8
#01 浮点数类型
height=197.6 #身高
print(height)
print(type(height))

x=10
y=10.0
print('x的数据类型:',type(x))  #int
print('y的数据类型:',type(y))  #float

x=1.99E1413
print('科学记数法:',x,'X的数据类型:',type(x))


#02 不确定的尾数问题
print(0.1+0.2)  #不确定的尾数问题 0.30000000000000004
#如果只是想得到0.1+0.2的结果,可以通过round保留指定位数
print(round(0.1+0.2,1)  #0.3

#03复数类型的使用
x=123+456j
print('实数部分:',x.real)
print('虚数部分:',x.imag)



#运行结果
197.6
<class 'float'>
x的数据类型: <class 'int'>
y的数据类型: <class 'float'>
科学记数法: inf X的数据类型: <class 'float'>
0.30000000000000004
0.3
实数部分: 123.0
虚数部分: 456.0

3布尔类型

布尔类型:

• 用来表示“真”值或“假”值的数据类型
• 在Python中使用标识符True或False表示布尔类型的值
• True表示整数1，False表示整数0
• 是不可变数据类型

布尔值为False的情况如下

• False 或者是None
• 数值中的0，包含0，0.0，虚数0
• 空序列,包含空字符串、空元组、空列表、空字典、空集合
• 自定义对象的实例，该对象的__bool__()方法返回False或__len__()方法返回0

        \#coding=utf-8
        x=True
        print(x)
        print(type(x))
        print(x+10)           #11 >>>> 1+10
        print(False+10)         #10 >>>> 0+10

        print('-------------------------')
        print(bool(18)) #测试一下整数18的布尔值 True
        print(bool(0),bool(0.0)）#False
        \#总结，非0的整数的布尔值都是True

        print(bool('北京欢迎你'))  #True
        print(bool(''))            #False

    # 所有非空字符串的布尔值都是True

        print(bool(False))  #False
        print(bool(None))    #False

##################运行得到
True
<class 'bool'>
11

## 10

True
False False
True
False
False
False

4字符串类型

字符串类型连续的字符序列，可以表示计算机所能识别的一切字符,是不可变数据类型 字符串的界定符：单引号、双引号、三引号(三个单引号和三个双引号都行)还有input函数输入的， str()函数转换的等。

    string1="hello"
    string2='hello'
    string3="""hello
    python"""
    string4='''hello
    world'''
    string5=input("input anything: ")
    string6=str(18)

    print(isinstance(string3,str)) # isinstance函数可以用来判断数据是否为某一个数据类型，返回值为True或False

    #coding=utf-8
    #01 字符串类型的使用
    city='天津'
    address="天津市宝坻区湘江大街3号"
    print(city)
    print(address)
    #多行字符串
    info='''地址:天津市宝坻区湘江大街3号
        收件人:XXXX
        手机号:18600000000
    '''

    info2="""地址:天津市宝坻区湘江大街3号
        收件人:XXXX
        手机号:18600000000
    """

    print(info)
    print('---------------------------------------------')
    print(info2)

字符串拼接

    name="daniel"
    str1="==="+name+"==="
    str2="===%s==="%(name)
    str3="==={}===".format(name)
    print(str1)
    print(str2)
    print(str3) # 三种方法结果一样

转义字符	描述说明
\n	换行符
\t	水平制表位，用于横向跳到下一个制表位
\”	双引号
\’	单引号
\\	一个反斜杠

原字符：使转义字符失效的字符，r或R

#coding=utf-8
#转义字符的使用
print('北京')
print('欢迎你')
print('-------------------------')
print('北京\n欢迎你')  #遇到\n即换行，可以连续换多行
print('北\n京\n欢\n迎\n你')

print('-------------------------')
print('北京\t欢迎你')   #/t制表位的大小取决于前面字符数量的多少
print('hello\tooooo')     #hello是5个字符，一个制表位是8个字符， 8-5=3
print('helloooooo')  

print('-------------------------')
print('老师说:\'好好学习，天天向上\'')  
print('老师说:\"好好学习，天天向上\"')  

#原字符,使得转义字符失效的符号r或R
print(r'北\n京\n欢\n迎\n你')
print(R'北\n京\n欢\n迎\n你')



##################运行得到
北京
欢迎你
-------------------------
北京
欢迎你
北
京
欢
迎
你
-------------------------
北京	欢迎你
hello	ooooo
helloooooo
-------------------------
老师说:'好好学习，天天向上'
老师说:"好好学习，天天向上"
北\n京\n欢\n迎\n你
北\n京\n欢\n迎\n你

索引:字符串又被称为有序的字符序列，对字符串中某个字符的检索称为索引,也叫做字符串的下标

切片:对字符串中某个子串或区间的检索称为切片 切片的语法结构 字符串或字符串变量[N:M] (从N开始到M结束，不包含M) 字符串或字符串变量[N:M:A] (从N开始到M结束，不包含M,步长为A)

#coding=utf-8
a="abcdefg"
print(a[0:3]) # 取第1个到第3个字符（注意，不包含第4个）
print(a[2:5]) # 取第3个到第5个字符（注意，不包含第6个）
print(a[0:-1]) # 取第1个到倒数第2个（注意:不包含最后一个)
print(a[1:]) # 取第2个到最后一个
print(a[:]) # 全取
print(a[0:5:2]) # 取第1个到第5个，但步长为2（结果为ace)
print(a[::-2]) # 字符串的倒序（类似shell里的rev命令,结果为geca)



#coding=utf-8
#字符串索引和切片的应用
str1='HELLOWORLD'
print(str1[0],str1[-10])  #序号0和序号-10表示同一个字符
print('北京欢迎你'[4]) #获取字符串中索引为4的。也就是'你'
print('北京欢迎你'[-1])

print(str1[2:7]) #从2开始到7结束不包含7 正向递增
print(str1[-8:-3]) #反向递减

print(str1[:5])  #默认N从0开始
print(str1[5:])  #M默认是切到字符串的结尾

##################运行得到
H H
你
你
LLOWO
LLOWO
HELLO
WORLD



#循环打印字符串
str1="hello,python"
for i in str1: # 直接用for循环遍历字符串
    print(i,end=" ")

#将字符串遍历打印,并对应打印出下标
#enumerate枚举，可以打印下标
str1="hello,python"
for i,j in enumerate(str1):
    print(i,j)

#输出得到
0 h
1 e
2 l
3 l
4 o
5 ,
6 p
7 y
8 t
9 h
10 o
11 n

字符串遍历打印

示例: 将字符串遍历打印,并对应打印出顺序号(从1开始，不是像下标那样从0开始)
str1="python"
for i,j in enumerate(str1):
    print(i+1,j)
    
#输出得到
1 p
2 y
3 t
4 h
5 o
6 n

常用的字符串操作

操作符	描述说明
x+y	将字符串x与y连接起来
x*n或n*x	复制n次字符串x
x in s	如果x是s的子串，结果为True，否则结果为False

#coding=utf-8
x='2022年'
y='北京冬奥会'
print(x+y)  #连接两个字符
print(x*10)  #对x这个字符串的内容复制10次
print(10*x)

print('北京'in y) #True
print('上海'in y) #False
 
##################运行得到
2022年北京冬奥会
2022年2022年2022年2022年2022年2022年2022年2022年2022年2022年
2022年2022年2022年2022年2022年2022年2022年2022年2022年2022年
True
False

常见字符串操作

abc="hello,nice to meet you"
print(len(abc)) # 调用len()函数来算长度       （常用）
print(abc.__len__()) # 使用字符串的__len__()方法来算字符串的长度

print(abc.capitalize()) # 整个字符串的首字母大写
print(abc.title()) # 每个单词的首字母大写
print(abc.upper()) # 全大写
print(abc.lower()) # 全小写
print("HAHAhehe".swapcase()) # 字符串里大小写互换

print(abc.center(50,"*")) # 一共50个字符,字符串放中间，不够的两边补*
print(abc.ljust(50,"*")) # 一共50个字符,字符串放左边，不够的右边补*            （常用）
print(abc.rjust(50,"*")) # 一共50个字符,字符串放右边，不够的左边补*

print(" haha\n".strip()) # 删除字符串左边和右边的空格或换行             （常用，处理文件很有用）
print(" haha\n".lstrip()) # 删除字符串左边的空格或换行
print(" haha\n".rstrip()) # 删除字符串右边的空格或换行

print(abc.endswith("you")) # 判断字符串是否以you结尾              （常用）
print(abc.startswith("hello")) # 判断字符串是否以hello开始         （常用）

print(abc.count("e")) # 统计字符串里e出现了多少次
print(abc.find("nice")) # 找出nice在字符串的第1个下标，找不到会返回-1
print(abc.rfind("e")) # 找出最后一个e字符在字符串的下标，找不到会返回-1
print(abc.index("nice")) # 与find类似，区别是找不到会有异常（报错）
print(abc.rindex("e")) # 与rfind类似，区别是找不到会有异常（报错）‘=


print(abc.isalnum())         #判断是否为数字字母混合（可以有大写字母，小写字母，数字任意混合）
print(abc.isalpha())         #判断是否全为字母（分为纯大写，纯小写，大小写混合三种情况）
print(abc.isdecimal())       #判断是否为检查字符串是否只包含十进制数字字符（即 0-9）。不包括任何其他形式的数字字符，如带有下标或上标的数字、分数等
print(abc.isdigit())         #判断是否为纯数字 
print(abc.islower())         #判断是否为纯小写字母
print(abc.isnumeric())       #判断是否为数值字符，这里的数值字符范围更广，不仅包括了 isdigit() 所涵盖的所有字符，还包括了其他语言中的数字字符（如罗马数字）、分数、带符号的数字等。
print(abc.isspace())         #判断是否为全空格

print(abc.upper().isupper()) #先把abc字符串全转为大写，再判断是否为全大写字母，结果为True

输入得到
22
22
Hello,nice to meet you
Hello,Nice To Meet You
HELLO,NICE TO MEET YOU
hello,nice to meet you
hahaHEHE
**************hello,nice to meet you**************
hello,nice to meet you****************************
****************************hello,nice to meet you
haha
haha

 haha
True
True
4
6
16
6
16
False
False
False
False
True
False
False
True

数字,字符串,元组是不可变类型（指的是改变值的话是在内存里开辟新的空间来存放新值，原内存地址里的值不变）下面的操作可以替换字符串的值，但原字符串没有改变。

    aaa="hello world,itcast"
    bbb=aaa.replace('l','L',2) # 从左到右，把小写l替换成大写L，并且最多只替换2个
    print(aaa) # 原值不变
    print(bbb) # 改变的值赋值给了bbb变量，所以这里看到的是替换后的值

    结果得到
    hello world,itcast
    heLLo world,itcast

列表,字典，集合是可变数据类型（在内存地址不变的基础上可以改变值）

print("root:x:0:0".split(":")) # 以:为分隔号,分隔成列表
print("root:x\n:0:0".splitlines()) # 以\n为分隔号，分隔成列表

结果得到
['root', 'x', '0', '0']
['root:x', ':0:0']

字符串的join操作

print(" ".join(['df', '-h'])) # 把列表里的元素以前面引号里的分隔符合成字符串

结果得到
df -h

小结：

• 引号引起来的，input()函数输入的，str()转换的都为字符串类型
• 多个字符串可以做拼接和格式化输出
• 字符串属于序列，属于序列的数据类型都有下标，可以循环遍历，可以切片，可以拼接
• 字符串属于不可变数据类型，不可变数据类型没有增，删，改这种操作

5列表

列表是一种基本的序列数据结构（字符串和元组也属于序列) 列表是一种可变值的数据类型（再次强调数字,字符串,元组是不可变类型） 列表的创建 使用中括号括起来，里面的数据称为元素。可以放同类型数据，也可以放不同类型数据，但通常是同类型。

name_list = ["张三", "李四", "王五", "马六"]

print(name_list)
print(type(name_list))
print(len(name_list))


得到：
['张三', '李四', '王五', '马六']
<class 'list'>
4

列表的下标 和字符串一样，见字符串的下标章

name_list = ["张三", "李四", "王五", "马六"]

print(name_list[0])
print(name_list[2])

for i in name_list:
    print(i)


for index,i in enumerate(name_list):
    print(index+1, i)

得到：
张三
王五
张三
李四
王五
马六
1 张三
2 李四
3 王五
4 马六

列表的切片,倒序 和字符串一样，见字符串的切片,倒序章节 示例:

#coding=utf-8

name_list = ["张三", "李四", "王五", "马六"]

print(name_list[1:3])
print(name_list[0:3:2])
#倒序
print(name_list[::-1])
print(name_list[-1:-4:-2])

得到：
['李四', '王五']
['张三', '王五']
['马六', '王五', '李四', '张三']
['马六', '李四']

通过reverse操作也可以实现倒序 通过reverse操作来倒序，并且是直接改变原数据（因为列表是可变数据类型）

name_list = ["张三", "李四", "王五", "马六"]

print(id(name_list))

name_list.reverse() # 通过reverse操作来倒序，并且是直接改变原数据（因为列表是可变数据类型）
print(name_list)
print(id(name_list))


得到：
2372866663872
['马六', '王五', '李四', '张三']
2372866663872


#以上可以说明对象在内存中的地址没有改变

列表的常见操作 增删改查等操作（针对 '元素' 的操作）

#coding=utf-8
name_list = ["张三", "李四", "王五", "马六"]

#增（增加元素）
## 在列表最后增加一个元素
name_list.append("田七")
print(name_list)

## 插入到列表，变为第三个
name_list.insert(2, "陈八")
print(name_list)


#删（删除元素）
#.remove后面填的元素
name_list.remove("李四")
print(name_list)


#.pop后面填的是下标
#删除操作，还可以使用del name_list[2]和name_list.pop(2);它们的区别del name_list是删除整个列表，os.pop()是默认删除列表最后一个元素；如果都用下标的话，则一样
name_list.pop(2)
print(name_list)

del name_list[2]

print(name_list)
#del name_list
#print(name_list)

#清空列表
name_list.clear()
print(name_list)

得到：
['张三', '李四', '王五', '马六', '田七']
['张三', '李四', '陈八', '王五', '马六', '田七']
['张三', '陈八', '王五', '马六', '田七']
['张三', '陈八', '马六', '田七']
['张三', '陈八', '田七']
[]

name_list = ['张三', '陈八', '田七']

#改（替换元素）
name_list[0] = "张三丰"
print(name_list)

#查
print(name_list[1])


得到
['张三丰', '陈八', '田七']
陈八



# 其它
print(os.count("centos"))  #统计元素出现的次数
print(os.index("centos")) # 找出centos在os列表里的位置
os.reverse() # 反转列表
print(os)
os.sort() # 排序列表，按ASCII编码来排序
print(os)
os.clear() # 清除列表所有元素，成为空列表,不是删除列表
print(os)



列表合并
list1=["haha","hehe","heihei"]
list2=["xixi","hoho"]
list1.extend(list2) # list1+=list2也可以，类似字符串拼接
print(list1)



双列表
name_list=["zhangsan","lisi","wangwu","maliu"]
salary=[18000,16000,20000,15000]
for i in range(name_list.__len__()):
    print("{}的月收入为{}元".format(name_list[i].ljust(10," "),salary[i]))
列表嵌套
emp=[["zhangsan",18000],["lisi",16000],["wangwu",20000],["maliu",15000]]
for i in range(emp.__len__()):
    print("{}的月收入为{}元".format(emp[i][0].ljust(10," "),emp[i][1]))




###查找最高工资的人是谁
name_list=["zhangsan","lisi","wangwu","maliu"]
salary=[18000,16000,20000,15000]
####最高工资是多少--》最高工资的下标--》下标对应的name_list的元素


print(name_list[salary.index(max(salary))])

6元组

元组就相当于是只读的列表;因为只读,所以没有append,remove,修改等操作方法. 它只有两个操作方法:count,index 元组,字符串,列表都属于序列.所以元组也有下标，也可以切片，也可以使用for来遍历

元组的创建与操作 列表使用中括号，元组使用小括号。

name1=["zhangsan","lisi","wangwu","maliu"]


print(type(name1))
name2 = tuple(name1)
print(type(name2))

##元组可以循环
print(name2[1])
for i in name2:
    print(i)

#元组可以切片
print(name2[-1:-3:-1])

#两个元组可以拼接，赋值到新的变量（元组是只读的）
name3= ["tianqi","chenba"]
name4 = name1 + name3

print(name4)



#####################得到结果
<class 'list'>
<class 'tuple'>
lisi
zhangsan
lisi
wangwu
maliu
('maliu', 'wangwu')
['zhangsan', 'lisi', 'wangwu', 'maliu', 'tianqi', 'chenba']

元组和列表的嵌套

元组是只读的，不代表元组里面任何数据不可变。如果元组里有列表。那么列表里是可变的。

emp2=(["zhangsan",18000],["lisi",16000],["wangwu",20000],["maliu",15000])
print(emp2[0][1])

print(id(emp2))

emp2[0][1] = 19000
print(emp2)
print(id(emp2))


#####################得到结果
18000
2322691275680
(['zhangsan', 19000], ['lisi', 16000], ['wangwu', 20000], ['maliu', 15000])
2322691275680

可变类型: 在值能改变的基础上,内存地址不变。 不可变类型: 改变值相当于在内存里新开辟一个空间来存放新的值，原内存地址的值不变。

练习

#小购物车程序 
#1,双十一来了，你的卡里有一定金额(自定义) 
#2,买东西，会出现一个商品列表(商品名，价格) #3,选择你要买的商品,卡里的钱够就扣钱成功，并加入到购物车;卡里钱不够则报余额不足 （或者做成把要买的商品都先加入到购物车，最后可以查看购物车，并可以删除购物车里的商品；确定后，一次性付款） 
#4,买完后退出，会最后显示你一共买了哪些商品和显示你的余额


money=20000
goods_list=[
    ["iphoneX",8000],
    ["laptop",5000],
    ["book",30],
    ["earphone",100],
    ["share_girlfriend",2000],
]
cart_list=[]

while True:
    for index,good in enumerate(goods_list):
        print(index+1,good)
    choice = int(input("请输入你要购买的商品编号: "))
    buy_good_price = goods_list[choice-1][1]
    if money >= buy_good_price:
        money -= buy_good_price
        cart_list.append(goods_list[choice-1][0])
    else:
        print("余额不足，请充值!")
        break
print(money)
print(cart_list)

7字典

• 字典:是一种key:value(键值对)类型的数据，它是无序的（没有像列表那样的索引,下标)(备：现在也有特殊方法实现的有序字典)
• 它是通过key来找value,就是hash表,查找速度快;
• 如果key相等,会自动去重(去掉重复值)。也就是说dict中没有重复的key，但是值是可以相等的
• 字符串,列表,元组属于序列,所以有下标，可以切片。字典和集合是无序的，没有下标，不能切片

字典的创建

dict1 = {
    'stu01':"zhangsan",
    'stu02':"lisi",
    'stu03':"wangwu",
    'stu04':"maliu",
}
print(type(dict1))
print(len(dict1))
print(dict1)
print(dict1["stu01"])

得到的值：
<class 'dict'>
4
{'stu01': 'zhangsan', 'stu02': 'lisi', 'stu03': 'wangwu', 'stu04': 'maliu'}
zhangsan

字典的常见操作：增删改查

dict1 = {
    'stu01':"zhangsan",
    'stu02':"lisi",
    'stu03':"wangwu",
    'stu04':"maliu",
}


# 增
# 类似修改,如果key值不存在,则就增加
dict1["stu05"]="tianqi"
print(dict1)




# 改
# 类似增加,如果key值存在,则就修改
dict1["stu04"]="马六"
print(dict1)
# 字典的增加与修改的写法是一样的，区别就在于key是否已经存在


# 查
print(dict1["stu01"]) # 如果key值不存在,会返回keyerror错误
# print(dict1.get("stu01")) # 这种取值方法如果key值不存在,会返回none,不会返回错误
# 删
dict1.pop("stu05") # 删除这条；也可以del dict1["stu05"]来删除
print(dict1)

dict1.popitem() # 删除显示的最后一条
print(dict1)

dict1.clear() # 清空字典
print(dict1)

# 删除整个字典
del dict1



###执行得到
{'stu01': 'zhangsan', 'stu02': 'lisi', 'stu03': 'wangwu', 'stu04': 'maliu', 'stu05': 'tianqi'}
{'stu01': 'zhangsan', 'stu02': 'lisi', 'stu03': 'wangwu', 'stu04': '马六', 'stu05': 'tianqi'}
zhangsan
{'stu01': 'zhangsan', 'stu02': 'lisi', 'stu03': 'wangwu', 'stu04': '马六'}
{'stu01': 'zhangsan', 'stu02': 'lisi', 'stu03': 'wangwu'}
{}

字典的其他操作

#coding=utf-8
dict1 = {
    'stu01':"zhangsan",
    'stu02':"lisi",
    'stu03':"wangwu",
    'stu04':"maliu",
}


print(dict1.keys()) # 打印所有的keys
print(dict1.values()) # 打印所有的values
print(dict1.items()) # 字典转成列表套元组
# 上面这三种可以使用for来循环遍历
for i in dict1.keys():
    print(i)
for i in dict1.values():
    print(i)
 # 字典转成列表套元组,输出下标0就是输出的key，下标1就是输出的value
for i in dict1.items():
    print(i)
for i in dict1.items():
    print(i[0])

得到的值：
dict_keys(['stu01', 'stu02', 'stu03', 'stu04'])
dict_values(['zhangsan', 'lisi', 'wangwu', 'maliu'])
dict_items([('stu01', 'zhangsan'), ('stu02', 'lisi'), ('stu03', 'wangwu'), ('stu04', 'maliu')])
stu01
stu02
stu03
stu04
zhangsan
lisi
wangwu
maliu
('stu01', 'zhangsan')
('stu02', 'lisi')
('stu03', 'wangwu')
('stu04', 'maliu')
stu01
stu02
stu03
stu04

字典练习01:打印出所有value为2的key

#coding=utf-8
dict1={
    '张三': 2,
    '田七': 4,
    '李四': 3,
    '马六': 2,
    '王五': 1,
    '陈八': 2,
    '赵九': 2,
}
for line in dict1.items():
    if line[1] == 2:
        print(line[0])

字典练习02

#coding=utf-8
city={
    "北京": {
        "东城":"景点",
        "朝阳":"娱乐",
        "海淀":"大学",
    },
    "深圳":{
        "罗湖":"老城区",
        "南山":"IT男聚集",
        "福田":"华强北",
    },
    "上海":{
        "黄埔":"xxxx",
        "徐汇":"xxxx",
        "静安":"xxxx",
    },
}

# 1. 打印北京东城区的说明（也就是打印出"景点")
print(city["北京"]["东城"])

# 2. 修改北京东城区的说明，改为"故宫在这“
city["北京"]["东城"]="故宫在这"
print(city["北京"]["东城"])

# 3. 增加北京昌平区及其说明
city["北京"]["昌平"]="昌平说明"
print(city["北京"])

# 4. 修改北京海淀区的说明，将"大学"改为"清华","北大","北邮"三个学校的列表
city["北京"]["海淀"]=["清华","北大","北邮"]
print(city["北京"]["海淀"])

# 5. 在大学列表里再加一个"北影"
city["北京"]["海淀"].append("北影")
print(city["北京"]["海淀"])

# 6. 循环打印出北京的区名,并在前面显示序号(以1开始)
for index,i in enumerate(city["北京"].keys()):
    print(index+1,i)
    
# 7. 循环打印出北京海淀区的大学,并在前面显示序号(以1开始)
for index,i in enumerate(city["北京"]["海淀"]):
    print(index+1,i)
    


####输入得到
景点
故宫在这
{'东城': '故宫在这', '朝阳': '娱乐', '海淀': '大学', '昌平': '昌平说明'}
['清华', '北大', '北邮']
['清华', '北大', '北邮', '北影']
1 东城
2 朝阳
3 海淀
4 昌平
1 清华
2 北大
3 北邮
4 北影

小结 字典是否属于序列？ 不属于 字典能否切片？ 不能切 “我要打印字典的第2个到第5个键值对”。这种说法是否正确？ 不对 字典是属于可变数据类型还是不可变数据类型？ 可变 字典里面可以嵌套字典，也可以嵌套列表或元组等其他数据类型。这种说法是否正确？ 正确

8集合

集合和字典一样都是使用大括号。但集合没有value，相当于只有字典的key。 字符串,列表和元组属于序列，是有序的，但集合是无序的，所以不能通过下标来查询和修改元素。

再总结一下： 整数，字符串，元组是不可变数据类型(整数和字符串改变值的话是在内存里开辟新的空间来存放新值，原内存地址里的值不变)

列表，字典，集合是可变数据类型(在内存地址不变的基础上可以改变值) 当然还有一种不可变集合我们这里不做讨论 集合主要特点:

1. 天生去重（去掉重复值）
2. 可以增，删（准确来说,集合可以增加删除元素，但不能修改元素的值)
3. 可以方便的求交集，并集，补集

**集合的创建 **

#coding=utf-8
set1 = {"stu01", "stu02", "stu03", "stu03"}
print(type(set1))
print(set1)

list1 = [1, 2, 3, 2, 4, 4, 5]
print(set(list1))
#得到
<class 'set'>
{'stu03', 'stu01', 'stu02'}
{1, 2, 3, 4, 5}

集合的交集，并集，补集

#coding=utf-8
set1 = {1, 2, 3, 2, 4, 4, 5}
set2 = {3, 4, 6, 7, 8}

#交集
print(set1.intersection(set2))
print(set1 & set2)
# 判断两个集合是否有交集,类型为bool(有交集为False,没交集为True)
print(set1.isdisjoint(set2))


#并集
print(set1.union(set2))
print(set1 | set2)

#补集
#set1有的，set2没有的
print(set1.difference(set2))
print(set1-set2)
#set2有，set1没有的
print(set2.difference(set1))
print(set2-set1)

# 对称差集
#两个补集相加，就是只有一方 有的
print(set1.symmetric_difference(set2))
print(set1^set2)

# 子集
set3=set([4,5])
# 判断set3是否为set1的子集
print(set3.issubset(set1)) 
# 判断set1是否包含set3
print(set1.issuperset(set3)) 

#运行得到
{3, 4}
{3, 4}
False
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 5}
{1, 2, 5}
{8, 6, 7}
{8, 6, 7}
{1, 2, 5, 6, 7, 8}
{1, 2, 5, 6, 7, 8}
True
True

集合的增加和删除

# 集合的增加操作
set1.add(88)
print(set1)
set1.update([168,998]) # 添加多个
print(set1)

# 集合的删除操作
set1.remove(88) # 删除一个不存在的元素会报错
print(set1)
set1.discard(666) # 删除一个不存在的元素不会报错，存在则删除
print(set1)

练习01

#coding=utf-8

math = ["张三", "田七", "李四", "马六"]
english = ["李四", "王五", "田七", "陈八"]
art = ["陈八", "张三", "田七", "赵九"]
music = ["李四", "田七", "马六", "赵九"]

# 1. 求同时选修了math和music的人
print(set(math).intersection(set(music)))

# 2. 求同时选修了math,enlish和music的人
print(set(math).intersection(set(english)).intersection(set(music)))
# 3. 求同时选修了4种课程的人
print(set(math).intersection(set(english)).intersection(set(music)).intersection(art))
#或者
print(set(math).intersection(set(english),set(music),set(art)))

# 4. 求报了math但没报音乐的人
print(set(math).difference(set(music)))
# 5. 求报了数学和音乐一共多少人
print(len(set(math).union(set(music))))


#运行得到
{'田七', '李四', '马六'}
{'田七', '李四'}
{'田七'}
{'田七'}
{'张三'}
5

集合小结 集合是只有key的字典（无序的，没有重复值，可以增加和删除），可以方便地求交并补集

8python数据类型总结:

1, 数字(int,float,bool,complex); 字符串, 列表,元组,字典,集合 2, 字符串，列表，元组属于序列，它们都有下标。字典,集合没有下标 3, 数字,字符串,元组是不可变类型; 列表，字典，集合是可变类型（不可变集合不讨论) 4, 可以做增,删操作的有列表,字典,集合。 5, 列表,字典可以修改里面的元素, 但集合不可以修改里面的元素。 6，天生去重的数据类型：集合，字典中的key 7，可以使用for循环遍历打印的数据类型有： 字符串，列表，元组，字典，集合 8，可以做四则运算的数据类型：数字

9python里括号使用总结:

小括号(): 用于定义元组; 方法调用; print打印; 函数,如len() 中括号(): 用于定义列表; 字符串,列表,元组取下标; 字典取key 大括号(): 用于定义字典,集合; format格式化输出用于取代%s这种的占位符也是大括号

四数据类型之间的相互转换

类型转换

• 隐式转换(运算的时候自动转换了)
• 显式转换（通过函数转换）

函数	描述说明
int(x)	将x转换为整数类型
float(x)	将x转换为浮点数类型
str(x)	将x转成字符串
chr(x)	将整数 x转换为一个unicode码对应的字符
ord(x)	将一个unicode码对应的字符x转换为其对应的整数值
hex(x)	将一个整数 x转换为一个十六进制字符串
oct(x)	将一个整数 x转换为一个八进制字符串
bin(x)	将一个整数 x转换为一个二进制字符串

    x=10
    y=3
    z=x/y  #在执行除法运算的时候，将运算的结果赋值给z
    print(z,type(z)) #隐式转换，通过运算隐式的转了结果的类型


    #float类型转换成int类型，只保留整数部分
    print('float类型转换成int类型',int(3.14))
    print('float类型转换成int类型',int(3.9))
    print('float类型转换成int类型',int(-3.14))
    print('float类型转换成int类型',int(-3.9))

    #将int转成float类型
    print('f将int转成float类型',float(10))

    #将str转成int类型
    print(int('100')+int('200'))

    #将字符串转成int或float时报错的情况
    #print(int('18a'))
    #print(int('3.14'))
    #print(float('45a.987'))

    #chr()ord()是一对
    print(ord('杨'))  #杨在unicode表中对应的整数值
    print(chr(26472))  #26472整数在unicode表中对应的字符是什么

    #进制之间的转换操作，十进制与其他进制之间的转换
    print('十进制转成十六进制:',hex(26472))
    print('十进制转成八进制:',oct(26472))
    print('十进制转成二进制:',bin(26472))







    ##################运行得到
    3.3333333333333335 
    <class 'float'>
    float类型转换成int类型 3
    float类型转换成int类型 3
    float类型转换成int类型 -3
    float类型转换成int类型 -3
    f将int转成float类型 10.0
    300
    26472
    杨
    十进制转成十六进制: 0x6768
    十进制转成八进制: 0o63550
    十进制转成二进制: 0b110011101101000

五eval函数

• Python中的内置函数
• 用于去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符串
• eval()函数经常和input()函数一起使用

#coding=utf-8
    s='3.14+3'
    print(s,type(s))
    x=eval(s) #使用eval函数去掉s这个字符串中左右的引号,执行了加法运算
    print(x,type(x))

 #eval函数经常与input()函数一起使用，用来获取用户输入的数值
    age=eval(input('请输入您的年龄:'))  #将字符串类型转成int类型，相当于int(age)

    print(age,type(age))
    height=eval(input('请输入您的身高:'))
    print(height,type(height))

    hello='北京欢迎你'
    print(hello)
    print(eval('hello'))  #输出了北京欢迎你

    print(eval('北京欢迎你'))  #会报错File "\<string>", line 1, in \<module>
    NameError: name '北京欢迎你' is not defined。 因为eval去掉引号之后，北京欢迎你并不存在这个变量

    \###########运行得到
    3.14+3 \<class 'str'>
    6.140000000000001 \<class 'float'>
    请输入您的年龄:11
    11 \<class 'int'>
    请输入您的身高:111
    111 \<class 'int'>
    北京欢迎你
    北京欢迎你

eval的语法格式 变量=eval(字符串)