Python-初识python

python的简介

创始人: Guido van Rossum(荷兰人，学数学出身)

时间：1989年圣诞节期间诞生

Python的命名：源于一个戏剧团（Monty Python）

python的应用领域：

系统运维
网络编程
科学计算
人工智能，机器人
web开发
大数据及数据库编程
云计算：分布式计算
教育：国外的第一门语言为python语言，在中国第一语言为c语言
游戏，图片
其他

python的优缺点：

优点：

面向对象（Java，c++，python）
免费
可移植:跨平带运行，兼容多种平台Windows/Linux/Unix
可混合编程（C/C++/Java/.net）
简单易学易用
应用领域广泛
开发效率高:出错几率比较小
开源

缺点

与C/C++相比执行速度不够快
不能封闭源代码

python的官网：www.python.org

python的版本：

python v2.7（2020年结束维护，出现bug之后没办法解决）

python v3.5（当前使用版本）

python v3.8（最新版本，正在开发中，不稳定）

python的安装：

可以安装在windows/Mac OS X /Unix....

python的运行

python的解释器

CPython(python):用C语言编写的
JPython：用Java语言编写的
IronPython：.net语言编写的
PyPy：用python语言编写的

python的运行：

$ python3 hello.py

或者$ chmod u+x hello.py

$ ./hello.py(在python文件中的第一行写入#！ /usr/bin/python3)

python的交互提示模式：

$ python3

>>> 可以在提示符下输入语句

退出：ctrl+d

>>>quit()

>>>exit()

python程序的组成：

程序由模块组成

模块由语句，函数，类，数据等组成

语句包含表达式

表达式建立并处理数据对象

python的注释：

# 井号开头，直至末尾：让注释内容不参加解释执行

python的核心数据类型

数字（整数，浮点数，复数，布尔型）

整型数 int：是不带小数部分的数字。包括自然数，0，以及负数如：-5 ，1000，0等

整型数的字面值表示：十进制表示（逢十进一）：（人们为什么使用十进制数：因为人有10只手指）

二进制表示（逢二进一）：以0b开头的数字表示二进制数，0b111，0b0111

八进制表示（逢八进一）：以0o开头，后跟0~7

十六进制表示（逢十六进一）：以0x开头，后跟0~9，A~F，a~f（不分大小写）

2.浮点型数 float

浮点型数是带有小数部分的数字

表示方式：小数形式：3.14 3.1 3. 0.14 .14

科学计数法：格式: 小数e/E(正负号) 指数，如：6.18E-1，2.9979e8

3. 复数 complex

分为两部分：实部（real）、虚部（image）虚部以j或J结尾(数学中是以i结尾的)

字面值：1j, (2j), 1+1J , 3-4J, (-100+100J)

布尔型数 bool ：

用来表示真和假来两个状态的类型，True表示真（条件满足或成立用1表示）False表示假（条件不成立或不成立用0表示）

　　　　　　　　bool值为假的有：空字符，空列表，空字典，空元祖，空集合，None

空值 None 对象(整个python程序中所有的None)

None是一个表示不存在的特殊对象

作用：用来占位，用来变量解除绑定

字符串

字符串 str

　　作用：用来记录文本（文字）信息

　　表示方法;在非注释中，凡是用引号括起来的部分都是字符串。单引号（'），双引号（"），三单引号（'''），三双引号（"""）

　　单引号和双引号的区别：单引号内的双引号不算结束符。双引号内的单引号不算结束符

　　三引号字符串：

　　　　作用：三引号字符串的换行会自动转换为换行符'\n'

　　　　　　　三引号内可以包含单引号和双引号

　　用转义序列代表特殊字符：

　　　　字符串字面值中，用字符反斜杠（\）后跟一些字符代表一个字符

　　　　字符串中的转义字符表：

　　　　　　\' 　　　　代表一个单引号

　　　　　　\"　　　　代表一个双引号

　　　　　　\\　　　　代表一个反斜杠

　　　　　　\n　　　　换行

　　　　　　\r　　　　返回光标只行首：print（aaaaa\rb）的结果为baaaaa

　　　　　　\f　　　　换页

　　　　　　\t　　　　水平制表符：print（"a\tb）的结果是b的前面有8个空格包括a如果a的个数为8则再新添加8个空格

　　　　　　\v　　　　垂直制表符

　　　　　　\b　　　　倒退：print（"ABCD\bE"）的结果为ABCE

　　　　　　\0　　　　空字符，字符值为0

　　　　　　\0XX　　 XX为两位八进制表示的字符：'\012'表示\n

　　　　　　\xXX　　　XX为两位十六进制的字符：\'00A'表示\n

　　　　　　\uXXXX 　 Unicode16的十六进制表示的字符

　　　　　　\UXXXXXXXX Unicode32的十六进制表示的字符

ASCII编码：(0~127(2**8-1))共有128个/Unicode16（65535个）

　　ASCII字符表

　　常用ASCCII编码：

　　　　字符　　　　十进制　　　　十六进制

　　　　‘0’　　　　　　48　　　　　　0x30

　　　　'A'　　　　　　65　　　　　　0x41

　　　　'a'　　　　　　97　　　　　　0x61

raw 字符串（原始字符串）

　　字面值格式：r'字符串内容' r"字符串内容" r'''字符串内容''' r"""字符串内容"""

　　作用：让转义字符\无效

　　示例：

字符串的运算：

　　算术运算符： + += * *=

　　+ 运算符用于字符串的拼接（只能拼接类型相同的两个对象，如：不能将字符串与整数拼接）

　　* 运算符用于生成重复的字符串（字符串只能与整数（int）相乘，与0相乘表示控字符串）

练习：打印一个长为（自由输入）宽为4的长方形，用*表示边框

w = int(input("请输入长方形的长："))
symbol = "*"
line1 = symbol * w
line2 = symbol + (w-2) * " " + symbol
print(line1)
print(line2)
print(line2)
print(line1)

字符串的比较运算：

　　运算符：> >= < <= == !=

　　比较方法：字符串相比相当于字符对应的ASCII值的比较，从第一个字符一次往后比较，ord('a')代表97 chr(97）代表a

in / not in 运算符：

　　作用：用于序列，字典，集合中，用于判断某个值是否存在于容器中，如果存在则返回True

　　格式：对象 in 容器；对象 not in 容器

字符串的索引操作：

　　python字符串str是不可以改变的字符序列

　　索引 index

　　　　索引语法：字符串[整数表达式]。（表达式的值为整数int）

　　　　说明：python序列都可以用索引（index）来访问序列中的对象（元素），

　　　　　　　python序列的正向索引是从0开始的，第二个所以为1，最后的一个索引为len（s）-1

　　　　　　　python序列的反向索引是从-1开始的，-1代表最后一个，-2代表倒数第二个，-len（s）代表第一个

切片 slice：

　　作用：从字符串中取出一部分相应的元素从新组成一个新的字符串

　　语法：字符串[（开始索引b）：（结果索引e）：（（步长s））]

　　注：（）内括起来的部分代表可以省略，左闭右开，开始索引/结束索引可以越界

　　说明：1、开始索引是切片开始切下的位置0代表第一个元素，-1代表最后一个元素

　　　　　2、结束索引是切片的终止索引（但不包括终止索引，左开右闭）

　　　　　3、步长是切片每次获取当前索引后移动的方向和位移量

　　　　　　 1）没有步长，相当于取值完成后向后移动一个索引的位置（默认为1）

　　　　　　 2）当步长为正整数时，取正向切片：步长默认值为1，开始索引默认值为0，结束索引默认值为len（s）。

　　　　　　 3）当步长为负整数时，取反向切片；默认的起始位置为最后一个元素，默认终止的位置为第一个元素的前一个位置。

　　示例：s ="ABDC"

　　　　　print(s[ : ]) #ABCD

　　　　　print(s[1：10000]) #BCD

　　　　　print(s[ : : 1]) #ABCD

　　　　　print(s[ : : 1-]) #ABCD

　　　　 print(s[ 3: 2])　　　 #为空

练习：输入任意一个字符串，判断这个字符串是否是回文（中心对称的字符串）

str = input("请输入任意的字符串：")
centre_index = round(len(str)/2)
print("你输入的是回文字符串") if str[ : centre_index ] == str[ : -(centre_index+1) :-1] else print("你输入的不是回文字符串")
################################################################################################################################
str = input("请输入任意的字符串：")
str1 = str[  :  : -1]
print("你输入的是回文字符串") if str == str1 else print("你输入的不是回文字符串")

python3中常用的序列函数：

　　len(seq) 返回序列的长度

　　max(x) 返回序列的最大值元素

　　min(x) 返回序列的最小值元素

　　示例：s = "ABCD"

　　　　　print(len(s)) #4

　　　　 print(max(s)) #D(根据ASCII值进行比较)

print(min(s)) #A(根据ASCII值进行比较)

字符串编码转换函数：

　　ord（c）返回一个字符串的Unicode编码值

　　chr（i）返回i这个值所对应的字符 i代表大于等于0的整数

整数转换为字符串函数：

　　hex（i）　　将整数转换为十六进制的字符串

　　oct（i）　　将整数转换为八进制的字符串

　　bin（i）　　将整数转换为二进制的字符串

字符串的构造（创建）函数 str

　　str（obj=“”）将对象装换为字符串

常用的字符串方法：

　　字符串方法的调用语法：对象.方法名（方法传参）

　　注：方法的调用属于表达式，通常可以返回一个值或None

　　示例：'abc'.isalpha() #正确（是不是字母a-zA-Z），中文也被看做为字母

　　S.isdigit()　　　　是否全部为数字

　　S.islower()　　　是否全部小写

　　S.isupper()　　　　是否全部大写

　　S.isspace()　　　　是否全部为空格（空白字符是指，水平制表符\t，换行符\n等不可见的字符）

　　S.center（width[,fill]）将字符串按width的宽度居中，[]为可选参数默认为空格，必须是str类型的，宽度可以小于字符串的长度

　　S.count（sub[,start[,end]]） sub字符在S字符串中有几个。start/end是字符串的索引，不包含end　　

　　S.find(sub[,strat[,end]]) 返回字符串中字串sub的第一个索引，失败返回-1

　　S.strip（）去掉字符串左右的空白字符

　　S.lstrip（）去掉左边的空白字符

　　S.rstrip（）去掉右边的空白字符

　　S.upper（）转换英文字母为大写

　　S.lower（）转换英文字母为小写

　　S.swapcase（）　　　　　大小写互转，遇到数字类型的字符串是不改变

　　S.capitalize()　　　　　　字符串结尾的大写字母转换为小写

　　S.replace(old,new[,count]) 将原字符串的old用new代替，生成一个新的字符串，count为替换的个数（超过old的次数或负值时全部替换），默认为全部替换。　　

　　S.startswith(prefix[,start[,end]]) 返回S是否为prefix开头，如果是则返回True，否则返回False

　　S.endswith(suffix[,start[,end]]) 返回S是否为suffix开头，如果是则返回True，否则返回False，（不包括end）

不常用的函数“

　　S.title()　　　　　　　　　　生成每个英文单词的首字母大写字符串

　　S.isnumeric()　　　　　　　　判断字符串是否全部为数字字符

字符串格式化表达式：

　　运算符：%

　　作用：生成一个格式的字符串

　　语法：格式字符串 % 参数值。

　　　　　格式字符串 % （参数值1，参数值2，参数值3.......）

　　　　　格式化字符串中 % 为占位符，占位符的位置将用参数值替换

格式化字符串中的占位符和类型编码：

　　　　占位符　　　　　　　　意义

　　　　　%s　　　　　　字符串，使用str（）函数转换

　　　　　%r　　　　　　字符串，使用repr（）函数转换

　　　　　%c　　　　　　整数转换为单个字符

　　　　　%d　　　　　　十进制整数

　　　　　%o　　　　　　八进制整数

　　　　　%x　　　　　　十六进制整数（a-f小写）

　　　　　%X　　　　　　十六进制整数（A-F大写）

　　　　　%e　　　　　　指数型浮点数（e小写）如：2.9e+10

　　　　　%E　　　　　　指数型浮点数（E大写）如：2.9E+10

　　　　　%f, %F　　　　浮点十进制形式

　　　　　%g, %G　　　　十进制形式浮点数或指数型浮点数自动转换，整数部分超过6位就会转换为指数型，不足6为则转换为十进制型浮点数，g对应e,G对应E

　　　　　　　　　　　　如果整数部分不足6位但是与小数部分加起来超过6位则会截取小数部分最后保留6位的浮点数

　　　　　%%　　　　　　等同于一个%字符（用于生成百分数）

占位符和类型码之间的格式语法：

　　% [格式语法] 类型码

　　格式语法：

　　　　-　　　　左对齐

　　　　+　　　　右对齐

　　　　0　　　　补零

　　　　宽度（整数）：宽度不能是变量

　　　　宽度.精度(整数)

　　　　示例：

　　　　练习：输入三行字符串，以三行中最长字符串的长度为标准进行右对齐输出

s1 = input(">")
s2 = input(">>")
s3 = input(">>>")
w = max(len(s1),len(s2),len(s3))
fmt = "%%%ds" %w #生成一个含有占位符的字符串("%ws")
print(fmt %s1)
print(fmt %s2)
print(fmt % s3)

列表

列表list

　　列表是由一系列特定的元素组成的，元素和元素之间没有任何关联关系，但他们之间有先后顺序关系

　　列表是一种容器

　　列表是序列的一种

　　列表是可以被改变的序列

python中的序列类型简介（sequence）（5中内建的序列容器）

　　字符串　　　　str

　　列表　　　　　list

　　元祖　　　　　tuple

　　字节串　　　　bytes

　　字节数组　　　bytearrag

创建一个空列表的字面值：

　　L = []　　　　#L绑定空列表

创建非空列表：

　　L = [1,2,3,4]

　　L = ["北京","上海","成都"]

　　L = [1,"two",3,"四"]

　　L = [1,2,[3.1,3.2,3.3,],4]

列表的构造（创建）函数 list

　　list（）　　　　　　生成一个空的列表等同于 [] 如：L = list（）

　　list(iterable) 　　　用迭代对象创建一个列表如　L = list（“ABCD”） L= lsit（range（1，10，2））

列表的运算：

　　算数运算：+ += * *=

　　+　　用于拼接列表

　　+= 　用于元列表与左侧可迭代对象进行拼接，生成新的列表

　　　　X = [1,2,3]

　　　　X += "ABC" #[1,2,3,"A","B","C"]　　右侧必须是可迭代对象

　　* 　　生成重复的列表

　　*=　　用于生成重复的列表，同时用变量绑定新列表（乘数必须是整数，如果是0或负整数则变为空列表）

　　比较运算：<　　<= 　　>　　>=　　==　　!=

　　　　　　根据索引最小的字符的ASCII的编码值进行比较，但是整数与字符串比较大小时回报TypeError，比较是否相等是可以正常运行的

列表的 in/ not in :

　　1、判断一个数据元素是否存在于容器（列表）内，如果存在返回True，否则返回False

　　2、not in 的返回值与 in运算符相反

列表的索引index / 切片 slice

列表的索引语句：

　　列表[整数表达式]

　　用法：列表的索引取值与字符串的索引取值规则完全相同

　　　　　列表的索引分为正向索引和反向索引

列表的切片

　　列表[:]

　　列表[: :]

　　列表的切片取值返回一个列表，规则等同于字符串的切片规则

列表的切片赋值语法：

　　列表[切片] =可迭代对象

　　说明:切片赋值的赋值运算符的右侧必须是一个可迭代对象

切片步长不为1的切片赋值：

　　切片注意事项：

　　对于步长不为1的切片的赋值，赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数（-1同样需要满足相同）

del 语句用于删除列表中的元素

　　语法：del 列表 [索引]

　　　　　del 列表 [切片]

python3中常用的序列函数：

　　len（x）　　　　返回列表的长度

　　max（x）　　　返回列表中最大的元素

　　min（x）　　　返回列表中最小额元素

　　sum（x）　　　返回列表中所有元素的和（元素必须是整数值类型）

　　any（x）　　　　真值测试，如果列表中其中一个元素为真值则返回True，否则返回False

　　all（x）　　　　真值测试，如果列表中所有元素都为真值，则返回True，只要有一个为假，则返回False

python3中常见的列表方法：

　　L.index(v[,begin[,end]])　　返回对应元素的索引下标，begin为开始索引，end为结束索引，当不存在时触发ValueError错误

　　L.insert(index,obj)　　　　将某个元素插入到列表中的指定位置,

　　L.count(x)　　　　　　　返回列表中元素的个数，没有则返回0

　　L.remove(x)　　　　　　从列表中删除第一次出现在列表中的值，如果不存在则会报ValueError

　　L.copy()　　　　　　　　复制此列表（只复制一层，不会复制深层对象）

　　L.append(z)　　　　　　向列表中追加单个元素

　　L.extend(lst)　　　　　　向列表中追加了一个了表

　　L.clear()　　　　　　　　清空列表，等同于L[:] = []

　　L.sort(reverse=False) 　　将列表中的元素进行排序，默认是按小到大的顺序排序，当reverse=True时，按从多大到小排序，列表中元素必须是同类型的数据

　　L.reverse()　　　　　　　列表的反转，用来改变原列表的先后顺序

　　L.pop([index])　　　　　删除索引对应的元素，如果不加索引，默认删除最后的元素，同时把删除的元素返回

字符串文本解析方法split 和 join

　　S.split(Sep=None)　　　　将字符串使用sep作为分隔符分割S字符串，返回分割后的字符串的列表，当不给定参数时，使用空白字符作为分隔符进行分割

　　S.join（iterable）　　　　用可迭代对象中的字符串，返回一个中间用S进行分割的字符串。

深拷贝 deep copy 和 shallow copy

浅拷贝：是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的复制过程

深拷贝：是指在复制过程中复制多层变量（不局限于两层），复制深层变量绑定的对象的复制过程

列表推导式 list comprehension

　　列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式

　　作用：用简单方法生成列表

　　语法：[表达式 for 变量 in可迭代对象] 或[表达式 for 变量 in 可迭代对象 if 真值表达式（真值表达式需要真执行表达式，为False时表达式不执行直接执行for语句）]

　　示例：L = [x*x for x in range(1,10)] #生成1-9的平方值的列表

　　　　　L = [x for x in range(1,100) if x%2!=0] #生成1-100内的奇数的列表

列表推导式的嵌套：

　　语法：[表达式1

　　　　　　for 变量1 in 可迭代对象1 if 真值表达式1

　　　　　　　　　for 变量2 in 可迭代对象2 if 真值表达式2

　　　　　　　.......]

　　示例：

元组tuple

元组是不可改变的序列，同list一样，元组可以存放任何类型的元素，一旦元组生成，则它不可以改变

元组的表达方式：

　　用小括号（）括起来，单个元素括起来用逗号（，）区分是单个对象还是元组如：type（（2））为int，但是type（（2，））为tuple

　　创建空元组的字面值：t = （）

　　创建非空元组的字面值：t = 200，

　　　　　　　　　　　　　t = （200，）

　　　　　　　　　　　　　t = （1，2，3）

　　　　　　　　　　　　　t = 100 ，200，300

元组的错误示例：t = （20）　　t绑定的是整数20

　　　　　　　　x， y，z =100，200，300 #序列赋值

　　　　　　　　x，y，z =“ABC” # x=“A”，y=“B”，z="C"

　　　　　　　　x，y，z = [10，20，30]

元组的构造函数 tuple

　　tuple（）生成一个空的元组，等同于（）

　　tuple（interable）用可迭代对象生成一个元组

　　示例：t = tuple（）

　　　　　t = tuple（range（10））

　　　　　t = tuple（‘hello’）

　　　　　t = tuple（[1,2,3,4]）

元组的算数运算： + += * *=，用法与列表的用法完全相同（有有点不同：列表的+=，*=运算前后列表的内存地址（id）没有发生变化，元组要发生变化）

元组的比较运算： < <= > >= == != 规则与列表完全相同

in / not in

索引取值

切片取值

　　规则与列表完全相同

　　区别：元组是不可变对象，不支持索引赋值和切片赋值

元组的方法：

　　T.index(v[,begin[,end]) 用于获取元组中v所在的索引位置，如果v不在元组中就会报错ValueError: tuple.index(x): x not in tuple

　　T.count(v)　　　　　　　用于获取元组中v的个数（同list.count()方法）

可以用于序列的函数：

　　len ，max，min，sum ,all, any

三个构造函数：用于创建相应的对象

　　str（obj）

　　list（iterable）

　　tuple（iterable）

其他函数：

　　reverse（sep）返回反向顺序的可迭代对象

　　sorted（iterable，reverse=False）返回已排序的列表

　　示例： for x in reverse("ABCD"):

　　　　　　　　print(x) # D C B A

字典 dict

1、字典是一种可变的容器，可以储存任意类型的数据

2、字典中的每一个数据都是用“键”（key）进行索引，而不像序列可以用下标进行索引

3、字典的数据没有先后顺序关系，字典的储存是无序的

4、字典中的数据以键（key）—值（value）对进行映射存储

5、字典的键不能重复，且只能用不可变类型作为字典的键

字典的字面值表示方式：

　　用{} 括起来，以冒号（：）分割键-值对，各键值对用逗号分隔开

创建空字典：d = { }

创建非空的字典：

　　d = {"name":"xdl","age":20}

　　d = {“姓名”：“小徐”}

　　d = {1:"壹"，2：“贰”}

字典的构造函数dict

　　dict（）　　　　创建一个空字典，等同于{}

　　dict（iterable）　用可迭代对象初始化一个字典

　　dict（**kwargs）关键字传参形式生成一个字典

示例：

　　d = dict()

　　d = dict([("name","xdl"),("age",20)])

　　d = dict(name="xdl",age=20) 如果d = dict(1="xdl",age=20)则会报语法错误：SyntaxError: keyword can't be an expression

不可变类型：

　　int , float, complex, bool, str ,tuple, frozenset(固定集合)，bytes(字节串)

可变类型：

　　list , dict, set， bytearray(字节数组)

字典的键索引：

　　用[] 运算符可以获取字典内“键”所对应的“值”

　　语法：字典[键]

　　获取数据元素：

　　　　d =dict(name="xdl",age=20)

　　　　print(d["age"]) #20

添加和修改字典的元素

　　字典[键] = 表达式

　　示例：d ={}

　　　　　d["name"] ="xdl"　　创建一个新的键值对

　　　　　d["age"] = 20 　　　创建键值对

　　　　　d["age"] = 25 　　　修改age对应的的值

del 语句删除字典的元素

　　语法：del 字典[键]

字典的 in/ not in 运算

　　可以用in运算符来判断一个“键”是否存在与字典中，如果存在则返回True，否则返回False ，not in 与 in返回值相反，判断的速度比在列表中要快。

字典的迭代访问：

　　字典是可迭代对象，字典只能对键进行迭代访问

可用于字典的内建函数：

　　len（x）　　返回字典键-值对的个数

　　max（x）　　返回字典的键的最大值

　　min（x）　　返回字典的键的最小值

　　sum（x）　　返回字典所有键的和

　　any（x）　　真值测试，只对键测试，如果其中一个键为True，结果为True

　　all（x）　　真值测试，全部键为True时，结果才返回True

字典的方法：

　　D.clear()　　　　　　　　清空字典

　　D.pop(key)　　　　　　　移除键，同时返回此键对应的值

　　D.copy()　　　　　　　　返回字典D的副本，值复制一层（浅拷贝）

　　D.update(D2)　　　　　　将字典D2合并到D中，如果键值相同，则此键的值取D2的值作为新值

　　D.get(key,default)　　　　返回键key所对应的值，如果没有此键，则返回default，默认为None

　　D.keys()　　　　　　　　返回可迭代的dict_keys对象　　　　#dict_keys([0, 9, 3, 6])

　　D.values()　　　　　　　返回可迭代的dict_values对象　　 #dict_values([0, 81, 9, 36])

　　D.items()　　　　　　　返回可迭代的dict_items对象　　　　#dict_items([(0, 0), (9, 81), (3, 9), (6, 36)])

字典推导式：

　　字典推导式是用可迭代对象依次生成字典内元素的表达式

　　语法：{键表达式：值表达式 for 变量 in 可迭代对象 [ if 真值表达式] }，[]的内容是代表可以省略，可以嵌套循环

　　示例：d = { x : x**2 for x in range(10)}　

　　　　 d = { x : x**2 for x in range(10) if x%3 ==0}

字典 vs列表

　　1、都是可变的容器

　　2、索引方式不同，（列表是整数索引，字典是用键索引）

　　3、字典的查找速度可能快于列表（重要），数据量越大越明显，但是当只有单个数据时可能会慢

　　4、列表的储存是有序的，字典的储存是无序的

集合 set

　　集合是可变的容器

　　集合内的数据对象是唯一的（不能重复多次的）

　　集合是无序的存储结构，集合中的数据没有先后关系

　　集合内的元素必须是不可变对象

　　集合是可迭代的

　　集合是相当于只有键没有值的字典（键则是集合的数据）

创建空的集合：

　　s = set（） #set（）创建一个空的集合

创建非空的集合：

　　s = {1，2，3} 集合中三个整数1，2，3　

集合的构造函数 set

　　set（）　　　　创建空集合

　　set（iterable）　用可迭代对象创建一个新的集合对象

　　示例：s = set("ABC") 　　　　　　　　#{'C', 'B', 'A'}

　　　　　s= set("AABBCCDD")　　　　　 #{'C', 'B', 'D', 'A'}

　　　　　s= set({1:"一",2:"二",5:"五"})　　 #{1, 2, 5}

　　　　　s=set([1,3.14,False])　　　　　 #{False, 1, 3.14}

　　　　　s=set((2,3.5,7)) 　　　　　　　 #{2, 3.5, 7}

　　　　　s= set([1,2,[3.1,3.2],4])　　　　 #因为列表中的列表是可变的对象，所以会报错：TypeError: unhashable type: 'list'

集合的运算：

　　交集&：生成两个集合的交集

　　　　　 s1 = {1,2,3}

　　　　　　s2 ={2,3,4}

　　　　　　s3=s1&s2 #{2,3}

　　并集|：生成两个集合的并集

　　　　　 s4 = s1 | s2 #{1, 2, 3, 4}　

　　补集-：生成两个集合的补集

　　　　　s5 = s1 - s2 #{1}

　　对称补集^：生成两个集合的对称补集

　　　　　s6 = s1 ^s3 #{1, 4} 等同于（s1 -s2）| (s2-s1)

　　子集<：判断一个集合是另一个集合的子集

　　　　　 s1 = {1,2,3}

　　　　　s2 = {1,2}

　　　　　s2 < s1 #True 表示s2是s1的子集

　　超集>：判断一个集合是另一个集合的超集

　　　　　s1 >s2 #True 表示s1是s2的超集

　　== / != :集合相同/不同，两个集合的元素和个数相同即可，没有顺序之分

in / not in 运算符

　　等同于字典，in运算符用于集合中，当某个值存在于集合中，则为真，否则为假，not in 与in 返回值相反

python3中可用于集合的函数：len（），max（）min（） sum（） any（） all（）

思考：

　　集合是可变对象，有方法能添加，删除集合的数据吗？

集合的方法：

　　S.add(e)　　　　　　　　　在集合中添加一个新元素e，如果元素已经存在，则不添加

　　S.remove(e) 　　　　从集合中删除一个元素e，如果元素不存在于集合中，则会产生:KeyError: 'a'的错误

　　S.discard(e)　　　　　　　从集合中移除一个元素e，如果元素不存在则什么都不做

　　S.clear()　　　　　　　　　清空集合内的所有元素

　　S.copy()　　　　　　　　　将集合进行一次浅拷贝

　　S.pop()　　　　　　　　　从集合中删除一个随机元素，并返回该元素，如果此集合为空，则引发：KeyError: 'pop from an empty set'

　　S.update(S2)　　　　　　　用S和S2得到的全集更新变量S 。S2可迭代对象，当不是可迭代对象时，报错：TypeError: 'int' object is not iterable

　　S.difference(S2) 　　　　　用S - S2运算，

　　S.difference_update(S2) 　　等同于S = S - S2

　　S.intersection(S2)　　　　　等同于S & S2

　　S.intersection_update(S2) 等同于S = S& S2

　　S.isdisjoint(S2)　　　　　　如果S 和S2的交集为空则返回True,否则返回False

　　S.issubset(S2)　　　　　　如果S 和S2的交集不为空则返回True,否则返回False

　　S.issuperset(S2)　　　　　　如果S是S2的超集返回True，否则返回False

　　S.symmetric_difference(S2) 等同于S^S2

　　S.symmetric_difference_upate(S2) 用S与S2的对称补集更新S

　　S.union(S2) 　　　　　　　　生成S与S2的全集

对于可变的对象，有时复合赋值运算符不等同于运算后再赋值

　　如：s1 = s1 |s2 不等同于 s1 |=S2

集合推导式：用可迭代对象创建（生成）集合的表达式

　　语法：{表达式 for 变量 in 可迭代对象 [if 真值表达式]} []括号部分的内容代表可以省略

　　示例：L = [2,3,5,7,3,5,7,11]

　　　　　s = { x**2 for x in L } #{9, 4, 121, 25, 49}

集合推导式的嵌套与列表推导式嵌套规则相同

固定集合 frozenset

　　固定集合是不可变的，无序的，含有唯一元素的集合

　　作用：固定集合可以作为字典的键，也可以作为集合的值（元素）

　　创建空的固定集合：fs =frozenset()

　　创建非空的固定集合：fs = frozenset([2,3,4,7]）

　　构造函数：

　　　　frozenset()

　　　　frozenset(iterable) #同set函数一致，返回固定集合

　　固定集合的运算：

　　　　&交集。|并集。-补集。^对称补集。> >= < <= == != in /not in (以上运算规则等同于set中的用法)

　　固定集合的方法：

　　　　相当于集合的全部方法去掉修改集合的方法

表达式和运算符（也叫操作符）

表达式expression：由一个数字或数字和运算符组成，一定会返回一个对象（数据）

作用：通常让计算机做一些事情并返回结果，如：1+2

运算符：

　　算数运算符：

+ 加法（1.0000+1.34=2.34）

- 减法

* 乘法

/ 除法（除法得到的数是浮点数，不会丢弃小数部分 4/2=2.0)

// 地板除（除的结果去掉小数部分向下取整，3/2=1,3.25//1.5=2.0),

% 求余(取模mod）10%3=1 10.0%3=1.0

** 幂运算（乘方）

　　比较运算符：<　　小于

<=　　小于等于

> 　　大于

　　　　　　　　>=　　大于等于

　　　　　　　　==　　等于

　　　　　　　　！=　　不等于

语法：左边表达式 < 右边表达式。比较运算符返回布尔类型的数值

示例：10 < 20 #True, 1+10 < 2+8 #False

　　布尔运算符：not and or

　　　　布尔非操作 not

　　　　　　语法：not x

　　　　　　作用：对x进行布尔取值，如bool（x）为Tue，则返回False，否则返回True

　　　　布尔与操作 and

　　　　　　语法：x and y 注：x，y代表表达式

　　　　　　作用：优先返回假值对象，当bool（x）的值为False时，返回x，否则返回y

　　　　　　示例：（）and 2 返回值为（），因为（）为空的元祖布尔值为False

　　　　布尔或操作 or

　　　　　　语法：x or y

　　　　　　作用：优先返回真值对象，当bool（x）为True时，则返回x，否则返回y

　　　　　　示例：

score = input("请输入成绩：") or "0"#如果什么都不输直接回车则score="0"
score = int(score)
if score < 0 or score >100:
    print("您输入的成绩不合法！！！")
else:
    print("您输入的成绩是：",score)

　　正负号运算符(一元运算符)：+（正号） -（负号）

　　　　语法：+ 表达式

　　　　　　　- 表达式

练习：

　　1、收费标准：3公里以内收费13元，超过3公里后基本单价为2.3元/公里，

　　　空驶费：超过15公里后，每公里加收基本单价的50%作为返程的空驶费（3.45元/公里）

　　　要求：输入公里数，打印出费用的金额（以元为单位进行四舍五入）

try:
    mileage =int(input("请输入公里数：") or "0")
    #mileage = int(mileage)
    if 0 <= mileage <=3:
        total_prices = round(13)
        print("您需要支付%s元" %total_prices)
    elif 3 < mileage <=15:
        total_prices = round(13 + (mileage-3)*2.3)
        print("您需要支付%s元" % total_prices)
    elif mileage > 15:
        total_prices = round(13 +(mileage-3)*2.3 + (3.45-2.3)*(mileage-15))
        print("您需要支付%s元" % total_prices)
    else:
        print("请输入有效的数值！！！")
except Exception as e:
    print("请输入有效的数值！！！")

　　2、给出一个年份，判断是否为闰年并打印结果

　　　闰年的规则：每四年一闰，每百年不闰，四百年又是一个闰年（2016年是闰年，2100年不是闰年，2400年是闰年）

year = int(input("请输入年份："))
if year % 400 == 0:
    print("是闰年")
elif year % 100 ==0:
    print("不是闰年")
elif year % 4 ==0:
    print("是闰年")
else:
    print("不是闰年")

运算符的优先级：（**）→（* / // %)→（+ -）

数值对象的构造（创建）函数

　　float(obj)：用字符串或数字转换为浮点数，如果不给参数则返回0.0如float（）返回值为0.0

　　int("x", base=10) ：x必须为有效的字符串（0~9，a~f，A~F），base表示前面的字符串是多少进制的数最大为36，默认为十进制，如int("110",2)返回结果为6

或 int（x=0）：用数字或字符串转换为整数，如果不给参数，则返回0，如int() 返回值为0，

　　complex（r, i):用数字创建一个复数，r表示实部，i表示虚部，如complex(1,2)返回1+2j，如果不给值则返回0j

　　bool(x):用x创建一个布尔值（True/False）

返回Flase的情况：一切空的东西皆为假

　　　　　　　　　　　　None、Flase、0、0.0、0j、0J、''、""、（）、[]、{}、set（）

　　函数调用：函数名()

说明：函数调用是表达式，一定返回一个对象的引用关系

基本输入、输出函数

　　输入函数input：是一个阻塞函数

　　　　作用：从标准输入设备上读如一个字符串（末尾的换行符会被删除（回车键））

　　　　格式：input（'提示字符串'）

　　　　说明：返回输入的字符串（仅python3）’提示字符串‘可以为空

　　输出函数print：

　　　　作用：将一系列的值以字符串的形式输出到标准输出设备上，默认为终端

　　　　格式：print(value,.....,sep=' ',end='\')

　　　　选项的关键字参数：sep两个值之间的分隔符（，），默认为一个空格

　　　　　　　　　　　　　end输出完毕后在流末尾自动追加一个字符，默认为换行符'\n'

变量 variable

什么是变量：变量是用来绑定数据对象的标识符

变量名的命名方法：

变量名必须为字母或下划线开头，后面跟字母或下划线或数字
不能使用python的关键字做变量名（大概有30多个）
变量不是使用表达式如 a+b =“hello”，会报语法错误SyntaxError: can't assign to operator，不等同于ab=“hello”

赋值语句 statement

　　语法：变量名 = 表达式如：a = 10

　　　　变量名1=变量名2=表达式如：a = b = 20

变量名1，变量名2 = 对象1，对象2 如 a ，b = 10， 20

　　作用：用于创建变量并将变量绑定（或关联）在一个对象上

　　说明：

1. 当变量不存在时，创建该变量同时绑定在这个对象上
2. 当变量存在时，改变此变量的绑定的对象
3. 一个变量只能绑定一个对象
4. 两个变量可以同时绑定同一个对象如 a = b =10，或a = 10 b = a （不能这样赋值a，b = 10）

　　实例：

a = 10 # 创建一个变量，和10绑定在一起

b = 20

c = a + b #创建变量c和10+20的结果绑定在一起

is / is not 运算符　　

　　作用：判断两个变量是否绑定同一个对象，如果是同一个对象返回True，否则返回False

小整数对象池：

　　CPython中整数-5~256永远存在于小整数池中，不会释放并可重复使用

del 语句（del是delete的缩写）

　　作用：用于删除变量，同时删除与对象的关联关系。如果可能则释放对象（a，b =10，10，此时10对象被a，b两个变量所绑定，删除其中一个则对象10不会倍释放）

　　语法：del 变量名1，变量名2......

　　python的内存管理和引用计数

　　　　每个对象都会记录有几个变量引用自身，当引用的数量为0时，则对象被销毁，此时自动化内存管理的方式叫引用计数（refrence count）

复合赋值算术运算符：

运算符	等同于
y += x	y = y + x
y -= x	y = y - x
y *= x	y = y * x
y /= x	y = y / x
y //= x	y = y // x
y %= x	y = y % x
y **= x	y = y ** x

练习：

在终端输出图像
中国古代的称是16两一斤，请问216两是古代的几斤几两？写程序打印出来
```
a, b=216, 16
print("216两是古代的%s斤%s两" %(a // b,a % b))#216两是古代的13斤8两
```
从凌晨0：0：0计时，到现在已经过了63320秒，请问现在是几时，几分，几秒？写程序打印出现在的时间（提示：可以使用地板除和求余实现）

seconds = 63320
hours = seconds//60**2
minutes = seconds % 60**2 // 60
now_seconds = seconds - hours *60**2 - minutes * 60
print("现在是%s:%s:%s" %(hours,minutes,now_seconds))#现在是17:35:20

内建的数值型函数：

abs（x）取x的绝对值
round(number [,ndigits]) 对数值进行四舍五入，ndigits是小数向右取整的位数，负数表示向左取整，是二进制的四舍五入可能有十进制的不同

pow（x，y，z=None）相当于x**y 或 x**y % z

语句 statement

　　语句是由一些表达式等组成，通常一条语句可以独立执行来完成一部分事情并形成结果。一条语句建议写在一行内，多条语句写在一行内需要有分号（；）分开

　　语句分为：（赋值语句、del语句、if语句、表达式语句）

　　示例：print("hello")

　　　　 x = 100 + 200

　　　　 print("hello");x=100+200#多条语句写在一行用分号分开

换行：

　　显示换行：折行号 \

　　隐藏式换行：所有的括号内、三单引号内和三双引号内换行、，称为隐式换行，括号：（），[], {}

if语句

　　作用：让程序根据条件选择性的执行某一条语句或某些语句

　　说明：if语句又叫条件语句，也叫分支语句

　　语法：if 真值表达式（必须返回True或False）1：

　　　　　　　　语句块1（四个空格的缩进）

　　　　　elif 真值表达式2:

　　　　　　　　语句块2

　　　　　......

　　　　　else:

　　　　　　　　最终的语句块

　　语法说明：elif子句可以有0个，1个或多个

　　　　　　　else子句可以有0个或1个且只能放在if语句的最后

if 语句的真值表达式：

　　if 100：

　　　　print（“真值”）

　　等同于 if bool（100）：

　　　　　　print（“真值”）

if语句的嵌套：

　　if语句本身是由多条子句组成的一条复合语句

　　if语句可以作为语句嵌套到另一个语句的内部

条件表达式：

　　语法：表达式1 if 真值表达式 else 表达式2

　　作用：如果真值表达式的布尔环境值为True，则执行表达式1并返回结果的引用，否则执行表达式2并返回结果的引用

money = int(input("请输入商品总额："))
pay = money -20 if money > 100 else money#如果money>100成立则返回前面的结果
print("您需要支付%s元"% pay)

pass语句

　　作用：通常用来填充语法空白，pass语句又名空语句

　　语法： pass

循环语句：

　　while语句

　　　　作用：根据一定条件，重复的执行一条语句或多条语句

　　　　语法：while 真值表达式：

　　　　　　　　　　语句块1（为真执行，一直循环）

　　　　　　　else：

　　　　　　　　　　语句块2（为假执行，结束循环）

　　　　说明：1、先执行真值表达式，判断True/False

　　　　　　　2、如果为True则执行语句块1，然后跳转到第一步

　　　　　　　3、如果为False则执行else子句部分的语句块2，然后结束此while语句的执行，如果没有else子句，则直接结束此while语句

　　　　　　　4、else子句部分可以省略（同if语句类似）

　　　　注意事项：

　　　　　　　1、要控制真值表达式来防止死循环

　　　　　　　2、通常用真值表达式内的变量来控制循环条件

　　　　　　　3、通常要在循环语句块内改变循环变量来控制循环的次数和变量走向

　　　　while语句嵌套

　　　　　　　while语句本身是语句，和其他语句一样，可以放在其他复合语句的内部：

　　　　　　　while 真值表达式1：

　　　　　　　　　　...

　　　　　　　　　　while 真值表达式2：

　　　　　　　　　　　　...

　　　　　　　　　　else:

　　　　　　　　　　　　...

　　　　　　　　　　...#控制外循环的次数

　　　　　　　else:

　　　　　　　　　　...　　　　　　　　

　　for语句

　　　　作用：用来遍历可迭代对象的数据元素（可迭代对象是指能依次获取数据元素的对象）

　　　　可迭代对象包括：

　　　　　　　列表 list

　　　　　　　元祖 tuple

　　　　　　　字典 dict

　　　　　　　集合 set

　　　　语法：

　　　　　　　for 变量列表 in 可迭代对象：（为什么是变量列表？）

　　　　　　　　　　语句块1

　　　　　　　else：

　　　　　　　　　　语句块2

　　　　说明：

　　　　　　　1、可迭代对象每次提供一个元素依次赋值给变量列表中的变量，赋值完毕后执行语句块1，重复执行此步骤，直到可迭代对象不能提供数据为止

　　　　　　　2、可迭代对象提供完所有元素后，执行else子句部分的语句块2，然后退出for语句

　　　　　　　3、else子句可以省略（同while语句类似）

　　　　　　　4、当在循环内部用break终止循环时，else子句部分语句不会执行

　　　　for语句的嵌套

　　　　　　　for语句内部可以放任意语句，包括for语句和while语句

break 语句：

　　作用：用于循环语句（while，for语句）中，用来终止当前循环语句的执行

　　说明：1、当brek语句执行后，此循环语句brek之后的语句将不再执行

　　　　　2、brek语句通常和if语句组合使用

　　　　　3、brek语句用于终止循环，循环语句的else子句的语句将不会执行

　　　　　4、brek语句只能终止当前循环语句的执行，如果有循环嵌套时，不会跳出嵌套的外部循环

　　　　　5、brek语句只能在循环语句（while或for语句）内部使用

死循环（death loop）：

　　　　死循环是指循环条件一直成立的循环

　　　　死循环通常用break语句来终止循环

　　　　死循环的else子句永远不会执行

range 函数：

　　range（stop）：从零开始，每次生成一个整数后加1操作，直到stop为止（不包括stop）

　　range（start，stop[,step]）：从start开始，每次生成一个整数后移动step，直到stop为止（不包括stop，且step可以是负整数）

　　作用：用来创建一个生成一系列整数的可迭代对象（也叫做整数序列生成器）

　　说明：range返回的对象是可迭代对象，可以用于for语句中

continue语句

　　作用：用于循环语句（while，for语句）中，不再执行本次循环内continue之后的语句，重复开始新的循环

　　说明：1、在while语句中，执行continue语句将会直接跳转到while语句的真值表达式处重新判断循环条件

　　　　　2、在for语句中，执行continue语句，将会从可迭代对象中取下一个元素，绑定变量后再次执行循环

阶段总结：

数据类型：

　　不可变数据类型：

　　　　bool, int , float, complex, str, tuple, frozenset, bytes

　　可变的数据类型：

　　　　list， dict， set ，bytearray（字节数组）

　　值：

　　　　None ，True， False ....

运算符：

　　+ - * / // % **

　　> >= < <= == ! =

　　is is not

　　in not in

　　not and or

　　& | ^ -

　　+(正号)　 - （负号）

表达式：

　　1+2

　　len（[1,2,3]）

　　条件表达式 x if x >y else y

　　全部的推导式：列表，字典，集合推导式（三种）

语句：

　　表达式语句：

　　　　print（“abc”）

　　　　“hello”

　　赋值语句

　　　　a = 100

　　　　a = b =c =200

　　　　x，y = 100，200

　　if语句，

　　while语句

　　for语句

　　break语句

　　continue语句

　　pass语句

　　del语句

内建函数：

　　len（x）

　　max（）

　　min（）

　　sum（）

　　any（）

　　all（）

***************************

　　bool（）

　　int（）

　　float（）

　　complex（）

　　str（）

　　list（）

　　tuple（）

　　dict（）

　　set（）

　　frozenset（）

**************************************

　　abs（）

　　round（）

　　pow（）

**************************************

　　bin（）

　　oct（）

　　hex（）

　　chr（）

　　ord（）

***************************************

　　range（[start,] stop[,step]）