新手小白学python（一）

标识符和变量

标识符

标识符是指用来标某个实体的一个符号，在不同的应用环境下有不用的含义。
标识符由字母、下划线和数字组成，而且不能够以数字开头。
标识符区分大小写，adc和Abc是不同的标识符。
标识符不能用关键字，如：class，int。

变量

变量可以值改变，类型也可以改变。
python中，对变量是不需要声明的。（这是与java，c等其他语言不同的地方）。python是动态语言，而c，java是静态语言。
在python中，可以对一个变量反复赋值，并且类型也可以不一样。
可以使用type函数查看变量类型：如type（a），就可以查看变量a的类型。
在python中，变量名也是大小写敏感的，即A和a是两个不同的变量。
同样，不要使用python的一些函数作为变量，比如：sum求和函数。
sum([1,2,3])可以求和得到5.
同样，sum不是关键字，因此sum符合变量的命名规则，所以理论上sum也可以作为变量被赋值，如sum=5.
但是，此时sum仅仅是一个整型变量，无法调用sum函数进行求和。
如何恢复sum函数的功能呢？
del(sum)即可。

python的变量，仅仅将名字与对象进行关联，让变量指向对象，而不是真正的赋值。

id函数：是内置函数，用来显示对象的地址，如：id（a）。

输入/输出函数

输入函数 input()

input():是内建函数，实现从键盘中读入一个字符串，如：
st = input()

注意： input()读入的数据均是字符串格式。倘若想得到其他的数据类型，需要输入之后进行强制类型转换，比如：
想读入一个整型123
st = int(input())
123
此时的st即为int类型。

倘若想在一行中输入多个值，则需要用split()函数，比如：
a, b = input().split()
123 987
可以得到a=‘123’,b=‘987’.

倘若想给出一个“请输入”的提示语，则可以：
n = input(“请输入一个字符串：”)
按下回车，此时会显示：
请输入一个字符串：

然后输入一个字符串赋值即可。

输出函数print()

print()函数：默认输出换行符。若不想换行，可以输出：
print(i,end = ‘’)

数字类型

整数

浮点数

取值和精度有限制
表示方式有两种：
1.小数： 1.23， -7.8
2.科学计数法：1.23 X 10^9 可以写为：1.23e9
0.000012 可以写为：1.2e-5
由于精度问题，十进制的0.1，用二进制表示，只能用无限接近0.1的小数来表示，因此，进行浮点数计算，会有一定的极小的尾数的精度误差。
比如：0.1+0.2,十进制是等于0.3的。
但是，在python中，做 0.1+0.2 == 0.3的判断，结果是Flase。这就是精度带来的影响。
如何消除这种精度误差的影响？
使用round()函数。
round(0.1+0.2,2)其中的2表示保留2位小数

复数（complex）

由实部和虚部组成，如：2+3j
使用real方法取实部，imag方法取虚部
complex()函数可用于创建一个值为real+imag*j的复数，比如：
a = complex(1,2)

算术运算符

/是浮点数除法，
//是整数除法。 此处的取整，是数轴上的向左取整。比如：
3//2 = 1, -3//2 = -2

注意，python可以实现浮点数的模运算。

数学库（math）函数

字符串类型

python中，不提供单字符类型（c中的char），全部以字符串（str）类型表示。
字符串：以引号括起来的任意文本。
字符串是一个有序序列。
字符串表示形式有：
1.单引号： ‘abc’
2.双引号： “abc”
3.三引号： ‘’’ hello
world’’’
三引号用来表示多行文本。
倘若字符串本身包含了单引号，那么该字符串可以用双引号括起来。
同理，若字符串本分包含了双引号，亦可以单引号括起来。
若该字符串中既有单引号，又有双引号，则用三引号括起来。

字符串运算符

注意，在字符串运算符这里，+只能连接两个字符串，而不能做字符串和整型的数相加。

字符串切片

字符串是一个顺序序列，可以是正向递增，也可以是反向递减：
索引：在[]中给出序号
切片：在[]中给出切片序号范围

关系运算

关系运算符

注意，字符串不能和数字进行比较。

逻辑运算（与、或、非、异或）

注意，python中执行短路运算，如：
输入：
3>5 and a>5
输出：
Flase
这是因为对于与运算，只要有一个为假，则为假。因此，判断3>5为假之后，计算机不会再判断a>5，而是直接输出结果 F；
而输入：
a>5 and 3>5
输出：
Traceback (most recent call last):
File “<pyshell#17>”, line 1, in
a>5 and 3>5
NameError: name ‘a’ is not defined
因为a没有定义，所以出错。

同理，对于或运算，倘若第一个为真，计算机不会再判断第二个式子的真假，直接输出结果True；

对于 非 ：
输入：
not 0
输出：
True

输入：
not 3
输出：
False
即在逻辑运算中，所有的非零值均看做真的逻辑量；

运算符的优先级和结合性

内置函数

python中封装了大量的内置函数，如：

运算类 内置函数

min，max

判断类 内置函数

操作类 内置函数

map()函数：map(function,iterable):就是对iteratable执行function函数

比如：
我们知道，
单个输入(字符串)是：x = input()
单个输入一个整数是：x = int(input())
多个输入(字符串)是：x,y = input().split()
得到x，y是两个字符串，倘若想同时输入两个int型，则需要再分别对x和y进行类型转换：x = int(x),y = int(y)

如果我们想多个输入整数：
可以调用map函数：
x,y = map(int,input().split())

内置转换函数

bool,int,float,complex,str可以看做类型转换函数
ord,chr,bin,oct,hex可以看做编码类转换函数
list就是列表转换函数，如：
输入：list(‘abcd’)
则字符串’abcd’转换为列表类型：[‘a’,‘b’,‘c’,‘d’]

对于int，
输入int()，得到结果0
输入int(“02”),得到结果0
输入int( " 35 "),得到结果35
输入int(“35”,8),得到结果29（8表示是八进制）

语句

赋值语句

python中，可以单赋值，如：a = 1
也可以序列赋值（左侧变量个数和值的个数相等），如：
x,y = 4,8,得到x=4，y=8
a,b = “34”,得到a=“3”,b= “4”
注意，交换a和b的值，不需要引入第三个变量，可以直接输入：
a,b = b,a 即可完成a和b的数值交换。

倘若等号两边个数不等，如：变量个数少于赋值的个数：
输入：
i,j =[1,2,3] 会报错
而输入：
i, *j =[1,2,3]
则，i =1，j=[2,3]

还可以多变量赋值，如：
a=b=c=5

if 语句

格式： if 逻辑表达式 ：
语句块1
else ：
语句块2

要注意首行缩进，python中的逻辑关系是通过缩进来实现的。没有缩进，会报错。
额外补充：对于输出y时，输出结果保留2位小数，可以这么实现:
print("{:.2f}".format(y))

for 语句

格式：
for 变量 in 列表：
语句块
例如： for i in [1,2,3,4]:
print(i)

range 函数

range(start,stop,step)
其中,start：计数从start开始，默认是0开始，例如：
range(5)等价于range(0,5)
stop：计数到stop结束，但不包括stop，例如：
list(range(0,5)) 是[0,1,2,3,4]，没有5
step：步长，默认是1，例如：
range(0,5)等价于range(0,5,1)
步长是正数，则得到一个递增序列，步长为负数，则可以得到一个递减序列，比如：
输入：
list(range(10,0,-1))
输出为：
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

推导式（解析式）

是python独有特性。
推导式，可以从一个序列构建另外一个序列。
推到式包括：列表推导式，字典推导式和集合推导式。

列表推导式

列表：是python中最常用的数据类型之一：
由零个或者多个元素组成，元素之间用逗号分隔开，这个列表用一个方括号所包裹。
元素类型可以相同，也可以不同、（这与其他语言中的数组不同）
通过序号可以引用列表中的元素。
支持加法、乘法、比较、索引、切片等操作，如：
加法： [1,2,3]+[‘c’,‘java’,‘python’]
输出：[1,2,3,‘c’,‘java’,‘python’]

乘法：[1] * 10
输出：[1,1,1,1,1,1,1,1,1,1]

比较：[1,2,3]<[2,3,4]
输出：True
这里的比较，仅比较两个列表中的第一个元素
比如：[2,5,6]<[1,3,4]
输出：False

比如：[1,5,6]<[2,3,4]
输出：True

索引：w = [1,5,6]
输入：w[0]
输出：1
输入：w[1]
输出：5

列表推导式：又称列表解析式，提供了一种简明扼要的方法来创建列表。
它可以将循环和条件判断相结合，从而避免语法冗长的代码，提高程序性能。
基本格式：
[expression for item in iterable]
例如：
普通的列表推导式：
n1 = [2 * number for number in [1,2,3,4,5]]
输出n1可以得到：[2,4,6,8,10]

带条件的列表推导式：
n1 = [ number for number in range(1,8) if number % 2 == 1]
输出n1可以得到：[1,3,5,7]

比如：求和1+1/2+1/3…+1/20
sum([1/i for i in range(1,21)])即可

比如：求和1-1/2+1/3-1/4…-1/10
sum([1/i if i % 2 ==1 else (-1)/i for i in range(1,11)])

比如： 求和6+66+。。。66666
sum([int(‘6’*i) for i in range(1,6)])

格式化输出format函数

之前提到过的，想要输出的结果result保留2位小数，则可以：
print("{:.2f}".format(y))

其基本格式为：str.format()
若想同时格式化输出多个结果，，则可以：
print("{0:.2f} {1:5f}".format(x,y))
其中0和1表示format函数中的第一个和第二个人参数
.2f和.5f分别表示表示保留2位小数和保留5位小数，四舍五入

容器

容器包括序列容器和无序列容器

序列类型容器

包括：字符串和列表。
字符串，如：‘abcef’
列表，如：[1,2,3,4,5]或者[‘a’,‘b’,‘c’,‘d’,‘e’,‘f’]
t=[1,2,3]
则通过索引可以取值，如：
输入：t[0]
输出：1
因此，t[]中能输入的是t列表中元素个数减一（因为是从0开始）
比如：
输入：t[3]
则会越界报错

若在t[]中输入负数，则是指葱油往左数，注意，从右往左的第一个元素的序号是-1而不是-0.
比如：
输入：t[-1]
输出：3

即容器中的每个元素都有两个编号，从左向右是正的，从0开始；
从右向左是负的，从-1开始。

我们还可以这样对列表中的值进行修改，比如：
输入：t[0] =5
此时的t列表变成了[5,2,3]

但是，不能通过这种方式对字符串进行赋值或者修改，比如：
n=‘abcd’
输入：n[0] = ‘f’
输出：会报错：TypeError: ‘str’ object does not support item assignment

字符串切片输出

如：
这里的切片，如[10:16],是指第十个到第十五个。
可以这么理解：
切片[a:b]，就是在a和b前面各且一刀，取出中间的部分，刚好是a到b-1这一段；

month = [‘26c’,‘8c’,‘560d’,‘qwer123456swxw’];
前三个如何只输出前三个？（不用循环）
month[0:3]即可

对于26c,8c,560d三个长度不同的字符串，如何使其只输出前几位的数字，而不输出最后一位的字母？

‘26c’[0:-1]
‘8c’[0:-1]
‘560d’[0:-1]

因为负数表示从右开始数，因此-1代表右边第一位，所以[0:-1]代表从第一位到最后一位的前一位的切片；
对于从0位（第一位）开始的切片，还可以省略0，如[0:123]可以简写为[:123];
同理，对于从中间某一位开始，一直取到最后的切片，可以把：后面的数字省略，比如：
‘helloWorld’,想取出World，按照常规，应该是’helloWorld’[5:10],注意，这个字符串其实是0-9，并没有’helloWorld’[10]这个元素，因此’helloWorld’[5:10]并不是很规范和安全。
正确的切片方法是：‘helloWorld’[5:]

序列的函数

1.len()函数：求长度。
对于列表来说，他的长度就是其中包含元素的个数。
比如：t = [12,34,5]
输入：len(t)
输出：3
2.min()和max()函数：用来求列表中的最小（大）的那个元素。
比如：
输入：min(t)
输出：5

字符串和数字之间的转换

.数字转换成字符串函数： str()函数（str()是一个全局函数，不是字符串自己独有的函数）

比如：
输入：str(123)
输出：‘123’

对于指定格式的数字到字符串的转化：

首先 %：
比如： 整数，用%d
输入 ：‘I am %d years old’ % 18
输出 ：‘I am 18 years old’

还可以控制要替换的数值占多大的距离：
比如：‘I am %10d years old’ % 18
输入：‘I am 18 years old’

对于有多个要替换的：% （x,y）
比如：
输入：‘I am %d years old and weight %d kg’ % (18,50)
输出：‘I am 18 years old and weight 50 kg’

对于有小数点精度要求的，可以用：%f
比如：
输入：‘it is %.1f ℃’ % 30
输出：‘it is 30.0 ℃’

综上，%就是字符串格式化的运算符。

字符串中有单引号或双引号时的处理和转义字符的使用

1.最简单的处理方法，若字符串中有单引号，则用双引号把字符串包裹起来；若字符串中有双引号，则用单引号把字符串包裹起来。
比如：对于字符串：I’m a good guy.
可以：“I’m a good guy.”

2.也可以使用转义字符（反斜杠\）
比如：‘I’m a good guy.’
输出：‘I’m a good guy.’

倘若一行装不下字符串的时候，可以使用三引号，还可以使用\，比如：
输入：’ this
is
a
test
’
输出：‘thisisatest’
这里的反斜杠的作用就是告诉电脑，到this这里字符串没有结束，下一行的is要紧紧和this相连在一起。

另外一个方法，如何保证字符串中的\n不被误认为是换行呢？
比如：
输入：s=r’this\nis\na\test’
输出s：‘this\nis\na\test’
而print(s),则会输出：this\nis\na\test
这里的r表示字符串那种的反斜杠,就是原始的字符\的意思，而不是转义字符。

字符串自己独有的函数

对于字符串自己的函数，调用是需要用 .来调用。
比如：

lower()函数：大写转化成小写

比如：s = ‘John Smith’
输入：s1 = s.lower
s1
输出：‘john smith’

注意，字符串自己本身的函数不会对自己本身做修改，而是产生以个新的字符串（这里是s1）这里的s.lower操作执行后，s仍然是’John Smith’,而不会变成’john smith’，这里要特别注意。

find()函数：在字符串找到子字符串并返回其位置位置

比如：
输入：s.find(‘hn’)
输出：2
这里的2就是h的位置
输入：s.find(‘ed’)
输出：-1
-1表示没有找到

像我们之前用的判断， ‘hn’ in s
输出：True，但是并不能告诉我们该子字符串的位置。

注意，倘若要查找的子字符串在字符串中出现多次，find函数仅返回第一个子字符串出现的位置。
比如：
输入：‘hello world’.find(‘l’)
输出：2

find()函数值还有第二和第三个参数，第二个参数告诉我们从哪里开始找子串，第三个参数告诉我们查找到哪里结束。
比如：
输入：‘hello world’.find(‘l’,4)
输出：9 因为我们从第4号位置开始找，因此找到了world中的l的位置9.

输入：‘hello world’.find(‘l’,4,8)
输出：-1，因为我们要求从第4号位置o处开始查找，到第8号位置r处结束查找，这一段没有l，因此返回-1表示没有查找到。

count()函数：用来查看要查找的子串在该字符串中出现的次数

比如：
输入：‘hello world’.count(‘l’)
输出：3

strip()函数以及他的引申函数rstrip()和lstrip()函数：用来去掉字符串中的空格，其中strip()去掉字符串两端的空格，rstrip去掉右端的空格，lstrip用来去掉左端的空格

比如：s = ’ hello world ’
输入：s.strip()
输出为：‘hello world’
输入：s.rstrip()
输出：’ hello world’
输入：s.lstrip()
输出：'hello world ’

replace()函数：替换一段为其他的内容

replace（‘a’,‘b’）:其中a为被替换的内容，b为要替换的内容
比如：
输入：s.replace(’ ‘,’-’)
输出：’-hello-world-’

再次注意，对字符串调用了无数次的字符串自身的函数，字符串本身不会改变。！！！！！！！！!！！！！！！！！！！

列表

list()函数：可以将字符串转换为列表

比如:
输入：t = list(‘this is’)
输出t，得到：[‘t’,‘h’,‘i’,‘s’,’ ',‘i’,‘s’]

列表中的元素还可以是列表，比如：t =[[1,2,3],[4,5,6],[7,8,9]]
输入：len(t)
输出：3

输入：t[0]
输出：[1,2,3]

输入：t[0][0]
输出：1
因此，可以看做是一个3X3矩阵。

注意：python中，列表变量是列表的管理者，而不是变量本身是一个列表

比如：
a1 =[1,2,3]
a2 = a1
则，此时，a1和a2输出均为：[1,2,3]
但是，此时：
输入：a2 [0] = 4
此时， a2 变成了[4,2,3]这是毫无疑问的，
但是，输出a1，会发现：
输入：a1
输出：[4,2,3]
a1也变了，这是很关键的一点。因为a2 = a1仅仅表示a2也成为了a1所管理的那个列表的管理者。

那么，如何获得a2,使得a2的列表内容和a1相同，但不是管理同一个列表呢？
方法就是：使用列表切片：
a2 = a1[:]即可

而:
n1 = 2
n2 = n1
n2 =3
输出n1和n2会发现，n1仍是2，n2变成了3.

del()函数：可以删除列表中的某个元素

比如：a = [1,2,3,4,5]
输入：del(a[2])
输出a得到：[1,2,4,5]

列表自己的函数，即用.函数来调用

append()函数：在列表后面添加一个元素

比如：a = [1,2,3,4]
输入：a.append(5)
输出a得到：[1,2,3,4,5]

注意，a.append([5,6,7])
会得到：[1,2,3,4,[5,6,7]]

这和extend()函数不一样

extend函数：把extend中的列表的值添加到要添加的列表的后面，注意是值，而不是把列表添加到该列表后面

比如：a= [1,2,3,4]
输入：a.extend([7,8,9])
输出a可以得到：[1,2,3,4,7,8,9]

insert()函数：把一个元素插入到列表的某个位置

形式：insert(address,content)
比如：a= [1,2,3,4]
输入：a.insert(2,10)
输出a可以得到：[1,2,10,3,4]，即把10插入到第2号位置。

注意：insert可以插入一个列表，比如：
输入：a.insert(1,[5,6,7])
输出a可以得到：[1,[5,6,7],2,3,4]

remove()函数：删除某个位置的元素

pop()函数：删除某个位置的值，默认是删除最后的值

比如：a=[1,2,3,4]
输入：a.pop()
此时输出a得到：[1,2,3]

还可以删除指定位置：
输入：a.pop(1)
此时输出a得到：[1,3,4]

pop()可以删除某个位置的元素值，并且返回该删除的值，比如：
输入：print(a.pop(1))
输出：2
2就是被删除的元素值。

reverse()函数：把列表中的元素顺序倒过来

如： a =[1,2,3,4]
输入：a.reverse()
此时输出a得到：[4,3,2,1]

index()函数：可以用来查找某个元素是不是在列表中

比如：a = [1,2,3,[5,6,7]]
输入：print(a.index([5,6,7]))
输出：3

字符串能和列表之间的操作

split()函数：把字符串分隔开，形成一个列表（字符串——>列表）

比如：a = ‘this is a test’
输入：a.split()
输出：[‘this’,‘is’,‘a’,‘test’]

再比如：b = ‘12:35’
输入：b.split(’:’)
输出：[‘12’,‘35’]

注意：
c = ‘12::35’
输入：c.split(’:’)
输出：[‘12’,’’,‘35’]
为什么呢？
因为split做操作： 12 ：：35
先查到第一个：，然后把：删掉，12分割出去得到’12’；然后查到第二个：，然后把：删掉，把？分割出去得到’’;再把最后的35分割成’35’,形成了列表[‘12’,’’,‘35’]

怎么把列表中的字符连接成字符串呢？
用 join()函数

join()函数：把列表中的字符连接成一个字符串（列表——>字符串）

比如：a = ‘this is a test’
t = a.split()
因此，t 就是[‘this’,‘is’,‘a’,‘test’]
输入：’ '.join(t)
输出：‘this is a test’
也就是说，用 (即空格)来把列表t连接起来。

序列容器之元组（我们已经学了另外两大序列容器：字符串和列表）

元组和列表很相似，只有两点不同：
1.元组用()来表示字面量，而列表用[]表示

2.元组是一种不可修改的数据。

比如：a = [1,2,3]
b = (1,2,3)
但是，输入：a[0]=4是ok的，可以执行的。
但是，输入：b[0]=4，
会报错：TypeError: ‘tuple’ object does not support item assignment
这一点和字符串一样，字符串也不支持修改。

元组也可以使用 对列表进行的一些操作，比如：len,min,max等函数。
但是，有一些函数是元组不能操作的。

会对元组本身造成修改的函数，元组是无法使用的，包括：append(),extend(),insert(),pop(),reverse(),join()等函数。

使用元组的一些场景

既然元组不如列表那么方便操作，为什么要使用元组？
比如：我们有一组数据，可以交给另一方查阅观看，但不想让他们修改，就可以以元组的形式传输这份数据给对方。

使用tuple()函数，可以把字符串或者列表转换成元组

比如：
a= ‘abc’
b = [1,2,3]
输入：c = tuple(a)
输出c可以得到：(‘a’,‘b’,‘c’)

输入：d = tuple(b)
输出d可以得到：(1,2,3)

倘若有用逗号分隔的量，则其天生被认为是元组：
比如：
输入：p=3,4
输出p可以得到：(3,4)

再比如：之前提到的同步赋值：
输入：a,b = 3,4
和输入：a,b = (3,4)
以及输入：(a,b) = 3,4
都是和(a,b) = (3,4)是一样的。

python的随机模块

sort()函数：可以对列表中的元素值进行排序

比如：a=[4,6,1,3,2]
输入：a.sort()
输出a得到：[1,2,3,4,6]

我们想要打乱一个有序的列表，怎么办呢？
这时，就需要引入一个随机模块（其实就是一个库），使用这个库中的一些函数可以实现打乱列表中的元素值的功能

随机模块（库）：random

random中的shuffle()函数：用来打乱列表（元组是不可修改的，所以不能对元组使用）

输入：import random
然后调用random中的一个函数shuffle就可以实现打乱。
输入：random.shuffle(a)
这时，a列表中的顺序就打乱了。

choice()函数：从列表（元组，字符串也可以）中随机选一个元素值出来

输入：random.choice(a)
输出：4（此为随机）

random()函数：随机给出一个(0,1)之间的小数

输入：random.random()
输出：0.7376170866004631

randint(a,b)函数：随机生成一个[a,b)之间的整数

seed()函数：给定一个seed,之后生成的随机数是相同的。

比如：

random.seed(0)
random.randint(1,100)
50

random.randint(1,100)
98
再次输入：

random.seed(0)
random.randint(1,100)
50

random.randint(1,100)
98
两次得到的randint是一样的。

因为randint的随机数，其实是电脑根据一定的公式计算出来的，给定固定的seed，输入相同的randint区间，永远会得到相等的随机值。

应用：这样一来，我们其实可以用来对一些软件做测试的时候，相同的随机数是非常棒的。

条件语句（if,else,elif）

格式：
if 条件：
执行代码
else ：
执行代码

或者：
if 条件：
执行代码
elif 条件：
执行代码
else：
执行代码

while循环语句

和其他语言一样

for循环语句(比其他语言多了一种用法else)

在python中，for循环比其他语言多了一种用法是：
for :
else:

比如：
for i in range(2,i):
执行语句1
else：
执行语句2
什么意思呢？
就是在for循环中，正常执行语句1
倘若for循环把range（2，i）全部执行完毕，没有提前终止for循环，则执行else中的语句2；如果for循环执行时，触发某个跳出for循环的条件，没有把range（2，i）全部遍历完，则不会执行else。

异常

异常处理（try，except）

try:
测试语句1
except:
测试语句1异常（报错时），要执行的语句2

针对不同的异常进行不同的处理：
try:
语句块1
except 异常类型1:
语句块2
except 异常类型2:
语句块3
.
.
.
except 异常类型N:
语句块n+1
except:
语句块n+2
else:
语句块n+3
finally:
语句块n+4

其中，
else:是指：倘若这次运行，没有报错，则会执行else中的语句块n+3。（类似于for+else）

finally:是指：无论try中的语句块有没有异常，都要执行finally中的语句块n+4.

集合{}（集合是一种容器）

集合的两大特点：1.没有重复的元素；2.无序，所谓无序，是指程序员无法指定元素在集合中的位置。
比如：
输入： s = {1,2,3,3,4}
输出s得到：s ={1,2,3,4}

再比如：
输入：s = {1,2,5,3,6}
输出s得到：s ={1,2,3,5,6}

set()函数：将列表，字符串，元组转换成集合

比如：t = [1,3,2]
s1 = set(t)
得到s1为{1,2,3}

注意：python中，直接输入{}不会得到一个空集合{}
即使 输入：{}不会报错，但是查看{}类型，你会发现：
输入：type({})
输出：<class ‘dict’>
这是一个字典dict，字典和集合公用花括号{}。

如何输入一个空集合呢？
方法：set()就会得到一个空集合。

集合的操作

add()和remove()函数对集合进行添加删除

min,max,len,sum()对集合进行操作

由于集合中的元素是无序的，所以不能够通过想列表那样使用下标来访问集合中的元素。

可以用>、<、<=、>=、=、来判断两个集合的关系

a<b:说明a是b的真子集
a=b:说明a和b是用一个集合
a<=b:说明a是b的子集

可以用 |取并集，用&取并集， 用^先取并集，再去掉交集

可以用s1-s2来取差集：在s1中去掉在s2中存在的元素

字典(dict) key：value 用key来访问value，而不能用位置访问（因为字典也是无序）:d[key]

格式：
d = {‘one’:1,‘two’:2}
其中，冒号前面的项叫做 键
冒号后面的项叫做 值
用键来访问值，比如：
输入：d[‘one’]
输出：1

字典添加一对键值对：使用直接赋值的方式:d[key] = value

如何往字典中添加键值对？
不能用add和append，而是直接赋值，比如：
d[‘three’] = 3即可

字典删除一对键值对：del()函数:del(d[key])

比如：
del(d[‘two’])就删除了字典d 中的’two’:2

字典修改一对键值对：直接修改：d[key] = value

访问value：除了直接访问：d[key]，还可以用get()函数

如：d.get(‘one’)

但是注意区别：
d[key]访问字典d中没有的键值对，会直接报错，比如：d[‘ok’],会报错
而使用d,get(‘ok’)，不会报错

还可这样使用get()函数：
d.get(‘ok’,0)
代表倘若d中没有’ok’这个ok,则其值value赋值为0添加到字典中。

函数

函数参数

位置参数

python中处理参数的方式比其他语言更加灵活，其中最熟悉的参数类型是位置参数，传入的参数的值是按照顺序依次赋值给形参。
比如：函数dis(x1,y1,x2,y2)
调用时：print(dis(2,3,5,6))即可。

关键字参数

调用参数时，可以指定对应形式参数的名字,他可以采用与函数定义时不同的顺序。
比如：一个函数 dis(x1,y1,x2,y2)
调用时：print(dis(x1=1,y2=4,y1=3,x2=7))是可以的。

注意，位置参数和关键字参数可以混合使用，在使用时，要先写位置参数， 然后才是关键字参数。
比如：
print(dis(1,3,y2=5,x2=9))是可以的。
但是，print(dis(1,y1=3,4,5))是错误的。X

默认值参数

在调用时，倘若调用方没有提供对应形参的值时，可以指定形参的默认值。而若提供了实参，则用实参的值。
即：有实参，用实参；没实参，用默认值。

比如：定义时：def dis(x1,y1,x2,y2 = 5)
调用时：
print(dis(1,3,8))
y2没有传实参，因此用默认值y2 = 5.
再比如：
print(dis(4,5,6,7))
y2有传实参7，则此时y2 = 7.

数量可变参数：一个星号和两个星号

当函数参数数目不确定时，星号将一组可变数量的位置参数 集合成 参数值的元组。
一个星号*:表示收集参数到元组。

两个星号**：表示收集参数到字典中。

实参拆包

*加在形参前面，表示不定长参数；而加在实参前面，表示将序列拆成一个个单独实参。

可变对象和不可变对象单参数，效果可能是不同的

当实参是不可变对象时，形参值改变不能影响实参；
当实参是可变对象时，形参值改变可能会影响实参。

change函数中的形参是不可变对象，因此，在函数体中，a=3，不会改变x的值。
而change1函数中的形参是一个列表，是可变对象。因此，在函数体中，a[0]=3，会使得l的列表元素值也改变。l[0]也从7变成了3.

函数返回值

第一种：倘若函数用return语句返回值，则return后面的表达式的值就成为本次函数调用的返回值。
第二种：倘若函数没有用return语句返回值，此时函数的返回值是None；如果return后面没有跟表达式，直接return返回，此时的返回值也是None。

注意：None是python中一个特殊的值，虽然它不表示任何数据，但仍然具有重要作用。

命名空间和作用域

1.变量可被访问的范围恒伟变量的作用域，又称作变量命名空间或者变量名字空间。Python用命名空间来区分不同空间的相同名字。

2.Python解释器启动时会建立一个全局命名空间，全局变量就放在此空间。此外，还建立内置命名空间，其中记录所有标准常量名，标准函数名等。在全局命名空间定义的变量是全局变量。

3.每个函数都有自己的命名空间，在函数内部定义的变量是局部变量。

global关键字：可以在函数内部定义一个全局变量

递归

递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要终止条件和递归条件。当终止条件不满足时，递归前进；当终止条件满足时，递归返回。编写递归函数时，必须告诉它何时停止递归，从而避免无限循环。

再学python内置函数

sorted()函数：对字符串，列表，元组，字典等对象进行排序

sort是仅应用在list，而sorted应用范围更广。
即便都是对列表操作，list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted返回的是一个新的list，而不是在原来的基础上进行操作。

sorted函数语法：

map()函数：会根据提供的函数对指定序列做映射。

语法：map(function,iterable)
返回值是一个新列表或者新的迭代器，其中的每个元素都是调用function函数的返回值。

zip()函数：用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表或者迭代器。

eval()函数：用来执行一个字符串表达式，并返回表达式的值

exec()函数：执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。

all()函数：将可迭代对象作为参数，当参数全为True，才返回True；否则返回False。

any()函数：将可迭代对象作为参数，当有一个参数为True时，返回True；全为False时，才返回False。

程序结构

引入模块：
方法一： import 模块名
方法二：from 模块名 import * 这种方法引入模块中的所有函数，调用时不需要再加模块名。

注意两种方式的区别：
方法一，引入模块之后，调用时需要加模块名，比如：
import math
使用math库中的fabs函数求绝对值，需要：
math.fabs(-10)
而方法二：
from math import *
fabs(-10)即可。

方法三：
from 模块名 import 函数名
是从模块中仅引入了一个函数。

模块名字空间

注意，主程序的模块名是"main"

包：把多个模块文件组织成目录，即为包

包是一个目录，其中包括：一组模块文件和一个init.py文件。
如果模块存在于包中，使用"import 包名.模块名"形式可以导入包中模块，用以下形式调用函数：“包名.模块名.函数”

sys模块：倘若两个或多个py文件不在同一个目录下，需要用sys模块加入搜索路径调用。

模块的查找路径：sys.path

sys模块中的常用量：

文件

文件读写

文件处理三个步骤：1.打开文件；2.处理文件；3.关闭文件。

open()函数：打开文件，其返回值是一个文件对象。

文件打开方式

文件读写函数

多行文件读写：readlines()函数

输入输出重定向

sys.stdin 标准输入
sys.stdout 标准输出
sys.stderr 标准错误输出

而：sys.stdin.read()重定向为键盘输入

python的模块函数分为3个层次：

一、内置函数

不用import语句引入，函数可以直接调用

二、标准模块函数：如math

用jmport语句引入模块后再调用，但是不必安装。

三、第三方模块函数：如pandas

需要先安装，再用import语句把模块引入，然后才能调用模块里面的函数。
第三方库安装：打开网页：https://pypi.org/
输入模块名，即可查询模块的详细说明。
在命令行下，pip install pandas，即可安装pandas模块。

pandas模块：读写常见格式文件

是一个数据分析包，提供了大量方便我们快速便捷处理数据的函数和方法。
用pandas可以读写各种类型的文件：

比如：读写csv文件：

DataFrame数据类型

是pandas库中的一种数据类型，它是一个行和列都具有标签的表格，他与excel表格没有不同。

plotly模块：基于JS的动态绘图模块

sqlalchemy模块：用于数据文件读写

类和对象的概念

类

类：是一种对象的模型和数据类型，它定义了对象的属性（数据），并提供用于初始化对象的初始化程序和操作这些属性的方法。

定义类，和其他语言类似：使用class关键字来定义类，class之后是一个空格，然后是类名，再然后是一个冒号，最后换行并定义类的内部实现。
格式：

class Classname:
	initializer   #初始化
	methods       #定义方法
	

比如，定义一个Students类

class Students:
	uname = '浙江大学'
	def _init_(self,ino,iname):   #_init_是一个特殊的方法，是构造方法，用于创建对象
		self.no = ino
		self.name = iname
	def getInofo(self):
		print('学校：',Students.uname,',学号:',self.no,',姓名:',self.name)

注意：定义类时，所有方法必须有self这个参数（可以不叫这个名字，位置必须在第一位），他代表对象本身。

对象

对象：是类的一个实例，使用构造方法来创建一个对象。使用圆点运算符(.)通过引用方法和变量啦访问对象的成员。

面向对象程序设计（oop）：使用对象进行程序设计，实现代码复用和设计复用，使得软件开发更高效方便。
python是真正面向对象的编程语言，完全支持面向对象的基本功能，包括：封装、继承、多态以及对基类方法的覆盖或重写。

比如：
s1 = Students(‘20131813’,‘ykk’) 这是创建了一个Students对象s1
s = ‘浙江大学’ 这是创建了一个字符串对象s，等价于s=str(‘浙江大学’)

而传统的C语言，是面向过程程序设计。

isinstance()函数：内置函数，用来测试一个对象是不是某个类的实例

isinstance(s1,Students)
True

访问对象

访问对象的数据：

s1.name

调用对象的方法：

s1.getInfo()

面向对象编程的三大特性：封装、继承、多态

封装

封装：将数据和对数据的操作组合起来构成类，类是一个不可分割的独立单位。
类中既要提供与外部联系的接口，同时又要尽可能的隐藏类的实现细节。

Python类中成员分为变量（数据、属性）和方法（函数）。

变量（数据）又分为：

1.类变量：是在类中所有方法之外定义的。
2.实例变量：一般是指在构造方法_init_()中定义的，定义和使用时以self作为前缀。
比如：

class Car:
	price = 10000           #定义类变量
	def _init_(self,color):
		self.color = c      #定义实例变量

car1 = Car('red')
car2 = Car('yellow')
print(car1.color,Car.price) #查看实例变量和类变量的值，但是查看price这个类变量的值，可以用类.price（即Car.price），也可以用对象.price(即car1.price)来查看。
Car.price = 11000  #修改类变量的值
Car.name = 'qq'    #动态增加类变量
car1.color = 'yellow'   #修改实例变量

方法（函数）又分为：

1.公有方法
2.私有方法：方法名以两个下划线’_'前缀
3.类方法：@classmethod
4.静态方法：@staticmethod

实例方法：在类的方法中第一个参数如果是self，这种方法称为实例方法。实例方法对类的某个给定的实例进行操作，可以通过self显式地访问该实例。

类方法：python中允许声明属于类本身的方法，即类方法。类方法不对特定实例进行操作，在类方法中不能访问对象的实例变量。类方法通过@classmethod来定义，以一个形式参数必须是类对象本身，通常为cls。

类方法和实例方法的不同：
1、类方法是属于整个类，而不属于某个对象。
2、类方法只能访问类成员变量，不能访问实例变量，而实例方法可以访问类成员变量和实例变量。
3、类方法的调用可以通过类名.类方法和对象.类方法，而实例方法只能通过对象.实例方法访问。
4、类方法只能访问类方法，而实例方法可以访问类方法和实例方法。
5、类方法不能被覆盖，实例方法可以被覆盖。

私有成员和公有成员：

在python中，以下划线’_'开头的方法名和变量名有特殊的含义，尤其是在类的定义中：
1._xxx：受保护成员，不能用’from module import *'导入；
2.xxx:系统定义的特殊成员。
3.__xx:私有成员，只有类内自己访问，不能使用对象直接访问到这个成员。