标签：元素
一、基础概念
1、集合：
集合是一个无序的、不重复的数据组，它的作用：
1）、去重复、把一个列表变成集合，就会自动去重
2）、关系测试，测试两组数据之间的交集、差集、并集等关系
集合的方法：
a、设置集合
>>>list_1 = [1,3,5,6,77,3,12] #列表1
>>>list_2 = [1,3,88,4,33,77] #列表2
>>>list_1 = set(list_1) #通过set方法可以将列表变为集合
>>>list_1
{1, 3, 5, 6, 12,77} #集合list_1现在已经去重
>>>list_2 = set(list_2)
>>>list_2
{1, 33, 3, 4, 77,88}
>>>print(list_1,type(list_1))#打印list_1类型，发现为set类型，证明为集合
b、取交集 intersection（list_1 list_2共有的元素）
>>>list_1.intersection(list_2)
{1, 3, 77}
>>> print(list_1 & list_2)
{1, 3, 77}
#上述两种方法均可以取出list_1与list_2的交集
c、取并集union（list_1 与list_2中全部去重元素）
>>>list_1.union(list_2)
{1, 33, 3, 4, 5,6, 12, 77, 88}
>>>list_1 | list_2
{1, 33, 3, 4, 5,6, 12, 77, 88}
#上述两种方法取两个集合的全部去重元素
d、取差集（差集是一个集合有，但是另一个集合没有的元素，所以差集可以得到两种不同的结果）
>>>list_1.difference(list_2) #list_1中存在但是list_2中不存在
{12, 5, 6}
>>>list_2.difference(list_1) ##list_2中存在但是list_1中不存在
{88, 33, 4}
>>> list_1 - list_2
{12, 5, 6}
>>> list_2 - list_1
{88, 33, 4}
基本操作：
a、添加（集合操作没有插入动作，只能添加）
>>> list_1
{1, 3, 5, 6, 12,77}
>>>list_1.add(999) #添加单项
>>>list_1.add(‘wang‘)
>>>list_1
{1, 3, 5, 6, 999,12, 77, ‘wang‘}
>>>list_1.update([‘alex‘,‘john‘,‘tom‘]) #添加多项
>>>list_1
{1, 3, 5, 6, 999,12, 77, ‘john‘, ‘tom‘, ‘wang‘, ‘alex‘}
b、删除
>>>list_1
{1, 3, 5, 6, 999,12, 77, ‘john‘, ‘tom‘, ‘wang‘, ‘alex‘}
>>>list_1.remove(999) #通过remove方法删除，删除后不显示删除项，删除需要明确指定删除项的内容，因为集合是无序的，没有索引的概念
>>>list_1
{1, 3, 5, 6, 12,77, ‘john‘, ‘tom‘, ‘wang‘, ‘alex‘}
>>>list_1.remove(wang) #针对字符串需要加引号
Traceback (mostrecent call last):
File "<stdin>", line 1, in <module>
NameError: name ‘wang‘isnot defined
>>>list_1.remove(‘wang‘)
>>>list_1
{1, 3, 5, 6, 12,77, ‘john‘, ‘tom‘, ‘alex‘}
>>> list_1.pop() #pop方法属于随机删除，删除后显示删除的内容
1
>>>list_1.pop()
3
>>>list_1.pop()
5
>>>list_1.pop()
6
>>>list_1.pop()
12
>>>list_1.pop()
77
>>>list_1.pop()
>>>list_1.pop()
‘john‘
>>>list_1
{‘tom‘, ‘alex‘}
c、discard删除
>>>list_1
{‘wang‘, 1, 3, 5, 6, 999, 12, 77, ‘john‘, ‘tom‘, ‘alex‘}
>>>list_1.discard(999)
>>>list_1
{‘wang‘, 1, 3, 5, 6, 12, 77, ‘john‘, ‘tom‘, ‘alex‘}
>>>list_1.discard(888) #discard与remove的不同之处在于，discard如果是删除不存在的内容，不会报错，但是remove会报错
>>>list_1.remove(999)
Traceback (mostrecent call last):
File "<stdin>", line 1, in <module>
KeyError: 999
d、长度len
>>>len(list_1)
10
>>>list_1
{‘wang‘, 1, 3, 5, 6, 12, 77, ‘john‘, ‘tom‘, ‘alex‘}
e、成员判断（in 和not in）
>>>list_1
{‘wang‘, 1, 3, 5, 6, 12, 77, ‘john‘, ‘tom‘, ‘alex‘}
>>> ‘wang‘in list_1
True
>>> 11 in list_1
False
>>> 11 notin list_1
True2、文件操作：
1、文件操作包括以下几种方式：
1）读模式
>>> data= open(‘yesterday.txt‘, ‘r‘) #open函数默认是读默认，所以r可以省略，但是为了规范最好写清楚已哪种方式打开
>>> print(data) #当打开这个文件后，print会返回该文件名字，默认与默认编码等文件本身属性
<_io.TextIOWrappername=‘yesterday.txt‘ mode=‘r‘ encoding=‘UTF-8‘>
2）写模式
>>> data= open(‘yesterday1.txt‘, ‘w‘) #文件已写模式打开
>>>data.write(‘1234\n‘) #当打开后，可以使用wirite方法进行写入操作，如果需要每行结束后换行，需要手动添加“\n” 这样保证在输入后进行换行操作，当写入后，会自动提示写了多少个字符
5
>>> f =data.read() #由于模式之间不兼容，如果只以写模式打开文件，进行读操作会报错
Traceback (mostrecent call last):
File "<stdin>", line 1, in <module>
io.UnsupportedOperation:not readable3）追加模式
>>> data= open(‘yesterday1.txt‘, ‘a‘) #和写模式不同，已追加模式打开文件，不会覆盖原文件内容，只会在文件后面进行添加，如果以w模式打开，会将文件原有内容全部清空，重新编写
>>>
>>>
>>>data.write(‘wwwyy\n‘) #对于写与追加模式，都可以进行write操作
6
>>> f =data.read() #追加模式也同样不能进行读操作
Traceback (mostrecent call last):
File "<stdin>", line 1, in <module>
io.UnsupportedOperation:not readable
总结：
文件打开最常用三种模式为读、写、追加。默认为open函数以读模式方式工作，在读模式中可以读取文件内容，写与追加模式均可以对文件进行修改，不同的是，读模式打开文件后，会将原有文件内容清空，添加新内容，而追加模式不会清空原有内容，会在文件最后添加新的需要追加的内容，至于如何在将r、w和a模式进行结合操作，会在修改文件时进行介绍
2、读模式的相关操作
1)read操作
>>> data= open(‘yesterday.txt‘, ‘r‘)
>>>data.read() #read操作会一次性将文件全部内容读取到内存中
‘往日重现\n\n当我年轻的时候\n听着收音机\n等待着我最喜爱的歌\n当它播放时我独自跟唱\n让我心情愉快起来\n\n就像那些快乐时光\n惊讶消失的无影无踪\n但当它们回来时\n就像是久没联络的朋友一样\n这都是我喜欢的歌\n\n每个Sha-la-la-la\n每个Wo-o-wo-o\n记忆依鲜明\n每个shing-a-ling-a-ling\n节奏依然美好\n\n当故事到了那个段落\n他伤了她的心\n让我流下泪来\n就像从前\n往日重现‘
>>>data.read() # 由于文件指针的存在，当一次性读取文件到内存后如果不进行指针回退操作前再次读取，会返回空值，表示该内容上一次已经读取完毕，本次读取没有内容显示
2）readline操作
>>> data= open(‘yesterday.txt‘, ‘r‘)
>>>data.readline() #与read操作一次性读取不同，readline操作每次只会读取一行内容存储到内存中，readline方法可以针对每行内容进行操作
‘往日重现\n‘
>>>data.readline()
‘\n‘
>>>data.readline()
‘当我年轻的时候\n‘
>>>data.readline()
‘听着收音机\n‘3）readlines操作
>>> data= open(‘yesterday.txt‘, ‘r‘)
>>> data.readlines()#区别于read于readline操作，readlines操作也是一次性读取，不同的是它会将读取的内容放入到一个列表中，这样后续可以操作列表的方式对该文件内容进行需要的操作4)close操作
>>>data.close() #在r、w、a操作的最后需要将文件关闭，采用close方法进行关闭，这样才会将文件修改保存到硬盘中，如果没有关闭操作，默认情况下都是在内存中进行操作的
5）文件的编码格式
>>> data= open(‘yesterday.txt‘, ‘r‘,encoding=‘utf-8‘) #在打开文件时需要跟文件的编码格式，python3中默认是采用utf-8格式的编码，所以可以省略
>>> print(data)
<_io.TextIOWrappername=‘yesterday.txt‘ mode=‘r‘ encoding=‘utf-8‘>
3、文件的其他操作
1）encoding：打印文件编码
>>>data.encoding
‘utf-8‘
2) fino（）返回文件句柄所在操作系统的编码 基本不使用操作
3）isatty（）该文件是否是一个终端设备，linux系统中可以用来判断是否是一个tty文件
4）name打印文件名称
>>>data.name
‘yesterday.txt‘5) seekable() 是否可以移动指针
>>>data.seekable()
True6) flush()刷新操作：
如果以写模式打开文件，写完后不一定立即写入磁盘，如果此时突然断电可能没有及时写入进文件，所以可以通过flush方法刷新进磁盘
例子：可以在安装程序时，打印进度条
import time,sys
for i in range(50):
sys.stdout.write(‘#‘)
sys.stdout.flush() #将#号实时刷新到屏幕上来
time.sleep(0.1)7）closed 判断文件是否关闭
>>>data.closed
False
>>>data.close()
>>>data.closed
True8) truncate()如果不写入任何东西就是清空文件
data.truncate(10)会只保留10个字节，其余的会删除，同时truncate自带文件指针，无论通过seek移到任何位置，truncate都会按照初始位置来删除与保留
4、修改文件：
修改文件分为两种模式：
1、将文件全部读入内存中，然后修改，该方式典型代表就是vim程序
2、将文件按照行模式读，然后每行操作完毕后再放入新文件，这种方式节约内存占用，类似与sed与awk操作
对于文件操作，除了典型r/w/a方式外还有其他操作，下面来简要介绍这几种更常用操作：
1）r+ 读写操作，表示又能读又能写，这个表示以读与追加模式开始，如果写，会将写的内容放入最后
2）w+写读模式，创建新文件，输入内容，然后读取文件指针所在位置，在回退，再输入，会发现插入的内容，仍然在最后而不是通过seek调转
3）a+追加读模式，在追加的过程中可以进行读
5、二进制文件
针对二进制文件有两种方式，rb与wb，其中两种情况下使用rb：
1、网络传输，socket传输时只能使用二进制格式编码
2、视频文件打开，也必须使用二进制格式打开
6、with语句
为了避免打开文件后忘记关闭，可以通过with来管理上下文，即：
>>> withopen(‘tes2.txt‘,‘w‘) as f:f.write(‘nnnnn\n‘)
...
如此方式，当with代码执行完毕后，内部会自动关闭并释放文件所在内存，同时也可以同时打开多个文件
with open(‘tes2.txt‘,‘w‘) as f, open(‘test3.txt‘,‘w‘) as f2:#两个文件之间用‘，’来分割
f.write(‘nnn\n‘)
f2.write(‘mmmm\n‘)
3、字符编码与转码
知识点：
1.在python2默认编码是ASCII, python3里默认是unicode
2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本，不过在文件里存的还是utf-8，因为utf8省空间
3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
在介绍编码之前先介绍下计算机语言与人类可识别语言转换：
计算机只能识别二进制编码，即0和1，在二进制编码中采用bit（位）来表示，但是这种方式对人类来讲是不可读的，所以初始阶段，发明了ASII码，即采用一个byte（8个bits）方式来表示人类可识别字母，2的8次方-1也就是使用255个ASII码来表示A-Za-z0-9这些数字与字母，但是对于非英语国家来说，255个字符表示没法完全表示自己本国语言，对于中国来说，本身采用了gbk gbk2308 gbk2312等编码方式来进行特定的编码，但是这种方式到了其他国家由于编码格式未统一，所以导致本国的程序到其他国家未必会被采用，基于这种情况，标注化组织开发了unicode即万国码的方式来代替了原有的各自为政的局面，unicode要求：最少已2个资金来表示，这样又引入了新的问题，就是比较浪费资源，所以最后统一使用utf-8编码方式：英语国家采用ASII编码，一个字节，欧洲等国家采用两个字节，而中国这种亚洲国家采用3个字节来表示自己的编码，至此解决了编码方式的问题
在说的编码与解码，由于类似bgk与utf-8之间没法直接转换，都需要经过unicode作为中转编码，所以需要编码与解码过程
import sys
print(sys.getdefaultencoding()) #打印得出默认编码为utf-8
utf-8
s = ‘你好‘ #在python3中默认编码为unicode
s_gbk = s.encode(‘gbk‘) #由于默认编码为unicode,所以这里从unicode到gbk编码采用的是encode模式,因为unicode没有decode过程了,可以直接encode
print(s_gbk) #这里输出为gbk编码格式
b‘\xc4\xe3\xba\xc3‘
s_to_utf8 =s.encode(‘gbk‘).decode(‘gbk‘).encode(‘utf-8‘) ‘‘‘从bgk变为utf-8:需要先把编码encode为bgk,然后在解码decode,解码是告诉自己为bgk，这时已经转换为unicode了,再从unicode状态encode成utf-8‘‘‘
print(s_to_utf8)
b‘\xe4\xbd\xa0\xe5\xa5\xbd‘
s_to_unicode =s.encode(‘gbk‘).decode(‘gbk‘).encode(‘utf-8‘).decode(‘utf-8‘) #在上面的基础上再使用decode模式解码到unicode
print(s_to_unicode)
你好
4、函数
1、编程方式
1）面向对象：类 定义用class
2）面向过程：过程，定义用def
3）函数式编程：函数，定义用def
其中函数式编程，其中没有任何变量，对于某一输入一定存在确定的输出，这种编程语言包括Lisp、relang，这里对函数式编码不做过多讨论
2、定义函数
def func1(): #通过def方式定义函数
‘‘‘testing‘‘‘
print(‘func1‘)
return 0 #函数可以有返回值
a = func1() #调用该函数
3、定义过程
def func2(): #定义过程与定义函数的区别在于定义过程是没有返回值的
‘‘‘testing‘‘‘
print(‘in the func2‘)4、调用函数与调用过程，查看返回值
def func1():
‘‘‘testing‘‘‘
print(‘func1‘)
return 0
def func2():
‘‘‘testing‘‘‘
print(‘in the func2‘)
a = func1() #调用函数1
b = func2() #调用过程2
print(a)
#打印返回值为0
print(b)
#打印没有返回值，按照默认来定义：None
5、使用函数的好处
1）代码的重复利用
2）程序容易扩展
3）保持代码的一致性
6、函数的返回值
def func1():
‘‘‘testing1‘‘‘
def func2():
‘‘‘testing2‘‘‘
return 1
def func3():
‘‘‘testing3‘‘‘
return 1,[1,2,3,4,5,6,7],(1,2,4,3,3,‘wang‘),{‘name‘:‘gavin‘,‘age‘:99}
a = func1()
b = func2()
c = func3()
print(a)
None
print(b)
1
print(c)
(1, [1, 2, 3, 4,5, 6, 7], (1, 2, 4, 3, 3, ‘wang‘), {‘age‘: 99, ‘name‘: ‘gavin‘})
返回值个数=0，返回None，系统默认返回空
返回值个数=1，反正object，定义哪个返回值，就返回哪个
反正值个数>1，返回tuple，当返回值个数大于1时，返回一个元组包含哪些需要返回的数值
7、形参与实参
def func1(x,y): #x与y时函数的形参，在没有调用该函数时，x与y不代表任何变量，不占用内存
‘‘‘testing1‘‘‘
x = x + y
return x
a =func1(10,20) #10与20是在调用该函数式传递给该函数的实参，目的是代替形参传入函数得到预期的结果
print(a) #在没有默认参数的情况下，形参与实参是需要一一对应的，如果调用时不一一对应会导致报错
30
8、默认参数
def func1(x,y=20):#y有默认参数，但是实际调用时没有实参对y赋值，y将采用默认参数，需要注意的是，默认参数要放在最后
def func1(x,y=20):#y有默认参数，但是实际调用时没有实参对y赋值，y将采用默认参数，需要注意的是，默认参数要放在最后
‘‘‘testing1‘‘‘
x = x + y
return x
a = func1(10)
print(a)
30
b = func1(11,21)
print(b)
32
默认参数特点：
调用函数时，默认参数可有可无，默认参数的用途是1在默认安装软件时使用，2在连接数据库端口号时使用
9、局部变量与全局变量
局部变量只在函数中生效，而全部变量是在整个程序中都生效的变量，代码顶层定义的变量，局部变量变成全局变量需要在函数中global这个局部变量，但是千万不要这么使用，但是需要注意的是，列表、字典、集合、类都是可以在函数中修改内容的，字符串与整数在局部变量中不能修改
name = ‘gavin‘
def my(name,age):
name = ‘jack‘ #局部变量
age = 23
return name,age
a =my(name,44) #name的局部变量在函数中生效变为jack,但是函数结束后仍然为gavin这个全局变量
print(a) #传入的44在函数中没有生效
(‘jack‘, 23)
print(type(a)) #返回值多于一个，反正的是tuple
<class ‘tuple‘>
print(a[0]) #可以按照元组方式调用返回值
jack
print(a[1])
23
print(name)
gavin
a = ‘gavin‘
def my(name):
global a #将a变为全局变量
name = ‘jack‘ #局部变量
a = ‘john‘
print(name,a)
my(‘a‘)
jack john
print(a)
john
names = [‘alex‘,‘gavin‘,‘tom‘]
def my():
print(names)
names[1] = ‘jack‘ #将全局变量中的names[1]修改为jack
return names
my()
[‘alex‘, ‘gavin‘, ‘tom‘]
print(names) #在打印时发现局部变量中的jack替换了全部变量中的gavin
[‘alex‘, ‘jack‘, ‘tom‘]10、递归
在函数内部，可以调用其他函数，如果一个函数在内部调用函数本身，这个函数就叫做递归函数
递归的特点：
1）必须有一个明确的结束条件
2）每次进入更深的一层递归时，问题规模相比上一次递归应有所减少
3）递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈这种数据结构实现的，每当进入一个函数调用，栈会增加一层栈帧，每当函数返回会减少一层栈帧，由于栈的大小不是无限的，所以递归次数过多会导致栈的溢出）
def calc(n):
print(n)
if int(n/2) > 0:
returncalc(int(n/2))
print(‘--->‘, n)
calc(10)
10
5
2
1
---> 111、高阶函数
变量可以指向函数，函数的参数能接受变量，那么一个函数就能接收另一个函数作为参数，这种函数叫做高阶函数
def add(a,b,f):
return f(a) + f(b)
res =add(3,-10,abs)
print(res)
13标签：元素
原文地址：http://12045355.blog.51cto.com/12035355/1933260
