一、集和

集合是一个无序的，不重复的数据组合，它的主要作用如下：

去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系
1.创建集合

>>> s = set([3,5,9,10])     #创建一个数值集合 
>>> t = set("Hello")    #创建一个唯一字符的集合
>>> s
{9, 10, 3, 5}
>>> t
{'e', 'H', 'l', 'o'}    #集和自动去重
>>> type(s),type(t)
(

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

>>> t
{'e', 'H', 'l', 'o'}
>>> "e" in t
True
>>> "a" in t
False
>>> "a " not in t
True
>>> for i in t:

    print(i)

    
e
H
l
o
3.更新集和

可使用以下内建方法来更新：

s.add()

s.update()

s.remove()

注意只有可变集合(set创建的集和，frozense创建的集和是不可变集和)才能更新：

>>> s
{9, 10, 3, 5}
>>> t
{'e', 'H', 'l', 'o'}
>>> s.add(1)    #添加一个元素
>>> s
{9, 10, 3, 5, 1}
>>> s.update([0,2,4])    #添加多个元素
>>> s
{0, 1, 2, 3, 4, 5, 9, 10}
>>> t.add('python')
>>> t
{'e', 'H', 'l', 'python', 'o'}
>>> t.update('python')    #添加一个字符会拆成多个
>>> t
{'e', 'y', 'n', 'h', 't', 'p', 'o', 'python', 'H', 'l'}
>>> t.remove('python')    #删除一个元素
>>> t
{'e', 'y', 'n', 'h', 't', 'p', 'o', 'H', 'l'}
4.集和关系操作

x in s  
测试 x 是否是 s 的成员  
  
x not in s  
测试 x 是否不是 s 的成员  
  
s.issubset(t)  
s <= t  
测试是否 s 中的每一个元素都在 t 中  
  
s.issuperset(t)  
s >= t  
测试是否 t 中的每一个元素都在 s 中  
  
s.union(t)  
s | t  # t 和 s的并集  
返回一个新的 set 包含 s 和 t 中的每一个元素  
  
s.intersection(t)  
s & t  # t 和 s的交集 
返回一个新的 set 包含 s 和 t 中的公共元素  
  
s.difference(t)  
s - t  # 求差集（项在s中，但不在t中）
返回一个新的 set 包含 s 中有但是 t 中没有的元素  
  
s.symmetric_difference(t)  
s ^ t  # 对称差集（项在t或s中，但不会同时出现在二者中）
返回一个新的 set 包含 s 和 t 中不重复的元素  
  
s.copy()  
返回 set “s”的一个浅复制  
del:删除集和本身，如“del t”

>>> s and t    #取t
{'e', 'y', 'n', 'h', 't', 'p', 'o', 'H', 'l'}
>>> s or t    #取s
{0, 1, 2, 3, 4, 5, 6, 9, 10}
>>> type(s)

打开文件的模式：

r， 只读模式【默认】
w，只写模式【不可读；不存在则创建；存在则删除内容；】
a， 追加模式【不可读；不存在则创建；存在则只追加内容；】
"+" 同时读写某个文件：

r+，可读写文件。【可读；可追加】
w+，写读
a+，追加读
"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

rU
r+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

rb
wb
ab

1 我越无所适从
2 越会事与愿违
3 在交错的时空
4 灵魂加速下坠
5 Here we are, here we are, here we are

默认操作文件
1.read()、readline()、readlines()的区别

f=open("haproxy.txt",encoding="utf-8")    #默认读取模式
print(f)    #不加参数，直接打印
'''
<_io.TextIOWrapper name='haproxy.txt' mode='r' encoding='utf-8'>
'''
print(f.read())    #read参数，读取文件所有内容
'''
我越无所适从
越会事与愿违
在交错的时空
灵魂加速下坠
Here we are, here we are, here we are
'''
print(f.readline())    #readline，只读取文章中的一行内容
'''我越无所适从'''
 
print(f.readlines())    #readlines，把文章内容以换行符分割，并生成list格式，数据量大的话不建议使用
#['我越无所适从\n', '越会事与愿违\n', '在交错的时空\n', '灵魂加速下坠\n', 'Here we are, here we are, here we are\n']

f.close()　　#关闭文件
 
f= open("har.txt",encoding="utf-8")
 
for index,line in enumerate(f.readlines()):    #先把文件内容以行为分割生成列表，数据量大不能用
    if index == 3:
        print("-----我是分割线-------")
        continue
    print(line.strip())
 
 
count = 0
for line in f:     #建议使用方法，每读取一行，内存会把之前的空间清空，不会占用太多内存,强推！！！
    count +=1
    if count == 4:
        print("-----我是分割线-------")
        continue
    print(line.strip())
     
#我越无所适从
#越会事与愿违
#在交错的时空
#-----我是分割线-------
#Here we are, here we are, here we are 
2、seek、tell光标

f= open("har.txt",encoding="utf-8")     #文件句柄
data = f.read()    #默认光标在起始位置，.read（）读取完后，光标停留到文件末尾
data2 = f.read()    #data2读取到的内容为空
print(data)
print("--------",data2)
f.close()    #关闭文件
#我越无所适从
#越会事与愿违
#在交错的时空
#灵魂加速下坠
#Here we are, here we are, here we are
#--------
 
#用seek移动光标位置
f= open("har.txt",encoding="utf-8")
print(f.tell())    #tell 获取当前的光标位
print(f.readline().strip())
print(f.readline().strip())
print(f.readline().strip())
print(f.tell())
f.seek(0)    #seek 移动光标到文件首部
print(f.readline().strip())    #从文件首部开始打印
f.close()      #关闭文件
#0
#我越无所适从
#越会事与愿违
#在交错的时空
#60
#我越无所适从
3.模拟进度条

import sys,time    #加载模块
 
for i in range(20):
    sys.stdout.write("》")
    sys.stdout.flush()    #flush 强制刷新缓存到内存的数据写入硬盘
    time.sleep(0.5) 
#如果不用flush刷新会等全部》写如内存之后再写入硬盘，效果就是一次出来20个》，用的话就像进度读条一样了，不信试试看。
三、字符编码与转码

 

#同志们注意了上图非常牛b
import sys
print(sys.getdefaultencoding()) #显示字符编码
a_unicode="夫风起于青萍之末" #这个是unicode格式
print(a_unicode)
a_gbk=a_unicode.encode('gbk')   #默认是unicode格式，转化为gbk格式
print(a_gbk)
a_gb2312=a_gbk.decode('gbk').encode('gb2312')   #先decode转化为unicode格式，括号里告诉自己是gbk格式的，再encode转化，括号里写要转化的格式。
print(a_gb2312) #gbk是gb2312升级版，常用汉字的编码基本相同
a_unicode2=a_gbk.decode('gbk')    #转化为unicode格式
print(a_unicode2)
'''
#执行结果在这里：
utf-8
夫风起于青萍之末
b'\xb7\xf2\xb7\xe7\xc6\xf0\xd3\xda\xc7\xe0\xc6\xbc\xd6\xae\xc4\xa9'
b'\xb7\xf2\xb7\xe7\xc6\xf0\xd3\xda\xc7\xe0\xc6\xbc\xd6\xae\xc4\xa9'
夫风起于青萍之末
'''
四、函数

终于到函数了。。。下面是多方总结：

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

特性:

减少重复代码
使程序变的可扩展
使程序变得易维护
1.函数定义

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以  def  关键词开头，后接函数标识符名称和圆括号  () 。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式]  结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
def sayhi():#函数名
    print("Hello, I'm nobody!")
 
sayhi() #调用函数
#下面这段代码
a,b = 5,8
c = a**b
print(c)
 
 
#改成用函数写
def calc(x,y):
    res = x**y
    return res #返回函数执行结果
 
c = calc(a,b) ＃结果赋值给c变量
print(c)
2.函数参数

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。

 

3.默认参数

def printinfo( name, age = 18 ):    #有默认参数时，如果age不传参就用默认的值。正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。
    print ("名字: ", name);
    print ("年龄: ", age);
    return;

#调用printinfo函数
printinfo( age=23, name="cheng" );
print ("------------------------")
printinfo( name="cheng" );

'''
名字:  cheng
年龄:  23
------------------------
名字:  cheng
年龄:  18
'''
4. 非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数。

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)
 
stu_register("Alex",22)
#输出
#Alex 22 () #后面这个()就是args,只是因为没传值,所以为空
 
stu_register("Jack",32,"CN","Python")
#输出
# Jack 32 ('CN', 'Python')
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)
 
stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
 
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}
5.局部变量

局部变量只在他的作用域内其起作用，也可以声明为全局变量，不过因为写代码长的时候随便声明可能会乱，所以不推荐。

def change_name(name):
    print("before change:",name)
    name = "里面的局部变量"
    print("after change:", name)
name=('外面的全局变量')
change_name(name)
print("在外面看看name改了么?",name)
'''
before change: 外面的变量
after change 里面的变量
在外面看看name改了么? 外面的变量
'''
6.返回值

要想获取函数的执行结果，就可以用return语句把结果返回。

注意:

函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束。
如果未在函数中指定return,那这个函数的返回值为None。
7.递归

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))
 
calc(10)
 
输出：
10
5
2
1
递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

 1 import random
 2 shopping_list = []
 3 shop_list = []
 4 add = []
 5 p = []
 6 condition = True
 7 identity_input = input(
 8                         "1. 用户\n"
 9                         "2. 商家\n"
10                         "请选择对应身份序号[1|2]：")
11 if str.isdigit(identity_input):
12     identity_input = int(identity_input)
13     if identity_input == 1:
14         money_input = input("欢迎用户访问,输入购物金额：")
15         if money_input.isdigit():
16             money_input = int(money_input)
17             with open("shoplist.txt", encoding='utf-8') as file:
18                 for list in file:
19                     shop_list.append((list.strip().split()[0], list.strip().split()[1]))
20                 while condition:
21                     for index, i in enumerate(shop_list):
22                         print((index+1), i)
23                     choice = input("请输入选择的商品序号,选择完毕q退出:")
24                     if choice.isdigit():
25                         choice = int(choice)
26                         if choice <= len(shop_list) and choice >= 0:
27                             p = shop_list[choice-1]
28                             a = int(p[1])
29                             if a <= money_input: #买的起
30                                 shopping_list.append(p)
31                                 money_input -= a
32                                 print("增加了%s商品，你的钱剩余%s" % (p, money_input))
33                             else:
34                                 print("余额不足,请重新选择，按q退出")
35                         else:
36                                 print ("商品%s不存在" % choice)
37                     elif choice == 'q':
38                             print("--------已购商品列表--------")
39                             for w in shopping_list:
40                                 print(w)
41                             print("余额为%s" % money_input)
42                             exit()
43     elif identity_input == 2:
44         print("欢迎商家访问：")
45         with open("shoplist.txt", encoding='utf-8') as file:
46             for list in file:
47                 shop_list.append((list.strip().split()[0], list.strip().split()[1]))
48             while True:
49                 for index, i in enumerate(shop_list):
50                     print((index+1), i)
51                 business_input = input(
52                                         "1.删除\n"
53                                         "2.添加\n"
54                                         "按q退出\n"
55                                       "请选择删除还是添加1|2：")
56                 if str.isdigit(business_input):
57                     business_input = int(business_input)
58                     if business_input == 1:
59                         business_choice = int(input("请输入要删除的商品序号:"))
60                         del shop_list[business_choice-1]
61                         c = 0
62                         with open('shoplist.txt', 'w', encoding='utf-8') as d:
63                             while c < len>64                                 d.write(shop_list[c][0])
65                                 d.write(' ')
66                                 d.write(shop_list[c][1])
67                                 d.write('\n')
68                                 c += 1
69                     elif business_input == 2:
70                         business_choice1 = input("请输入要添加的商品名称:")
71                         business_choice2 = input("请输入要添加的商品价格:")
72                         add.append(business_choice1)
73                         add.append(business_choice2)
74                         shop_list.append(add[-2:])
75                         with open('shoplist.txt', 'a', encoding='utf-8') as f:
76                             f.write(business_choice1)
77                             f.write(' ')
78                             f.write(business_choice2)
79                             f.write('\n')
80                     else:
81                         print("请输入正确的序号!!!!!!!!!!!!!!!!!!!!!!")
82                 elif business_input == 'q':
83                     print("正在退出。。。 。。。")
84                     exit()
85     else:
86         print("身份输入错误，程序退出。。。 。。。")
87 else:
88     print("输入错误，没有输入的身份序号。")

购物车程序

矿泉水 10
可乐 20
咖啡 30
橙汁 40

程序需要文件，命名shoplist.txt

文件 File

　　文件是用于数据存储的单位
　　文件通常用来长期存储数据
　　文件中的数据是以字节为单位进行顺序存储的

文件的操作流程
　　1. 打开文件
　　2. 读/写文件
　　3. 关闭文件
　　注: 任何操作系统，一个应用程序同时打开文件的数量有最大数限制

文件的打开函数:
　　open(file, mode='rt') 用于打开一个文件，返回此文件流对象
　　如果文件打开失败，则会触发OSError类型的错误
文件的关闭方法:
　　F.close() 关闭文件，释放系统资源

 View Code

文件的读方法:
　　F.read([n])
　　F.readline()
　　F.readlines()

文件的写方法:
　　F.write(s) # 写入字符串或字节串(二进制模式)到文件中
　　F.writelines(lst) # 写入字符串或字节串列表到文件中

读文件模式:
　　'r' 只读
写文件模式:
　　'w' 只写,可创建文件
　　'x' 只写,当文件已存在时不创建文件,文件不存在于才创建文件
　　'a' 追加写

文件 File

　　文件是用于数据存储的单位
　　文件通常用来长期存储数据
　　文件中的数据是以字节为单位进行顺序存储的

文件的操作流程
　　1. 打开文件
　　2. 读/写文件
　　3. 关闭文件
　　注: 任何操作系统，一个应用程序同时打开文件的数量有最大数限制

文件的打开函数:
　　open(file, mode='rt') 用于打开一个文件，返回此文件流对象
　　如果文件打开失败，则会触发OSError类型的错误
文件的关闭方法:
　　F.close() 关闭文件，释放系统资源

 View Code

文件的读方法:
　　F.read([n])
　　F.readline()
　　F.readlines()

文件的写方法:
　　F.write(s) # 写入字符串或字节串(二进制模式)到文件中
　　F.writelines(lst) # 写入字符串或字节串列表到文件中

读文件模式:
　　'r' 只读
写文件模式:
　　'w' 只写,可创建文件
　　'x' 只写,当文件已存在时不创建文件,文件不存在于才创建文件
　　'a' 追加写

 View Code

文件的迭代读取
　　文本文件流对象是一个可迭代对象,可以用for语句来遍历每一行数据迭代过程将以'\n' 作用为隔符依次获取
　　示例:
　　　　fr = open('myfile.txt')
　　　　for line in fr:
　　　　　　print(line)

标准输入输出文件
　　sys.stdin # 标准输入文件
　　sys.stdout # 标准输出文件
　　sys.stderr # 标准错误输出文件(默认是屏幕终端)
　　模块名: sys
　　注: 标准 输出输出文件不需要打开了关闭就可以使用

 View Code

二进制文件操作
　　二进制文件模式字符: 'b'
　　默认文件中存储和都是以字节(byte)为单位的数据,通常有人为的格式对二进制文件的读了需要用字节串(bytes)进行操作与文本文件操作不同,二进制文件读写过程中不会进行自动的编解码转换

 View Code

二进制文件的随机访问
　　F.tell() 返回当前文件的读写位置(从文件头以字节为单位)
　　F.seek() 设置文件读写位置
　　格式:
　　　　F.seek(偏移量, whence=相对位置)
　　偏移量:
　　　　大于0的数代表向文件末尾方向移动
　　　　小于0代表向文件头方向移动
　　相对位置
　　　　0 代表从文件头开始偏移
　　　　1 代表从当前读写位置开始偏移
　　　　2 代表从文件尾开始偏移

 View Code

 

 View Code

文件小结:
　　打开模式:
　　　　't' 文本文件打开(默认)(自动进行编解码)
　　　　'b' 二进制文件打开
　　操作方式:
　　　　读:
　　　　　　F.read(n)
　　　　　　F.readline()
　　　　　　F.readlines()
　　　　写:
　　　　　　F.write(字节串或字符串)
　　　　　　F.write(字节串或字符串列表)

汉字编码
　　国标系列
　　　　GB18030(二字节或四字节编码, 27533个汉字)
　　　　　　GBK(二字节编码, 21003个汉字)
　　　　　　　　GB2312(二字节编码,6763个汉字+682个字符)
　　　　(windows常用)
　　国际标准
　　　　UNICODE32(四字节编码) <----> UTF-8
　　　　　　UNICODE16(二字节编码)
　　　　(Linux/IOS/ Android 常用)

　　UTF-8 (8bit-UNICODE Transformation Format)
　　　　0x0000 ~ 0x007F 1字节表示
　　　　0x0080 ~ 0x07FF 2字节表示
　　　　0x00800~ 0xFFFF 3字节表示(中文在此区)

python 编码(encode) 字符串
　　'gb2312'
　　'gbk'
　　'GB18030'
　　'utf-8'
　　'ascii'
　　示例:
　　　　s = "ABC中文"
　　　　b1 = s.encode('gbk') # b1 为7字节
　　　　b2 = s.encode('utf-8') # b2 为 9字节

1.文件的处理

假设在当前的目录下有一个'abc.txt'

1)重命名文件

os.rename('abc.txt','a123.txt')

>>'abc.txt'变成了'a123.txt'

2)删除文件

os.remove('a123.txt')

但是在删除之前，最好先判断'a123.txt'是否存在

改成:

if os.path.exists('a123.txt'):

os.remove('a123.txt')

2.文件路径的处理

假设有一个文件路径

path='/users/Python/Data/info.txt'

1)获得路径

print os.path.dirname(path)

>>/users/Python/Data

2)分割文件名

print os.path.basename(path)

>>info.txt

3)分割文件的后缀

print os.path.split(path)

>>('/users/Python/Data', 'info.txt')

3.创建并访问目录

比如创建一个test01,test02目录

1)创建目录

os.mkdir('test01')#在当前目录下创建一个test01目录

os.mkdir('test02')#在当前目录下创建一个test02目录

改进，最好在创建之间先判断目录是否存在，否则会报错

if not os.path.exists('test01'):

os.mkdir('test01')

if not os.path.exists('test02'):

os.mkdir('test02')

2)列出当前目录下的所有文件和文件夹

|---test01--------

|---test02--------

|---demo_file.py--

print os.listdir('.')

>>['demo_file.py', 'test01', 'test02']

有同学说我不知道这个test01是文件夹还是文件啊，不急有高招，接着看

print list(os.walk('.'))#walk()会生成当前目录下的所有文件和目录

>>[('.', ['test01', 'test02'], ['demo_file.py']), ('.\\test01', [], []), ('.\\test02', [], [])]

3)返回当前的目录

print os.getcwd()

>>C:\Users\xx\Python\Test

4)删除目录

os.rmdir('test02')

>>就把test02文件夹删除了

有同学问若test02里面还有其他文件和目录，怎么办，如何一键删除.可以用一个高级模块shutil来处理,详细的我后面会有文章介绍文件的高级处理技巧

4.判断是否为文件或者目录

在文件处理的时候，特别是递归处理目录下的多个文件或者嵌套子目录的时候，要先判断一下这个是文件还是目录.

python有非常简单的方法,假设我们有一个这样的目录结构:

|---test01--------

|---test02--------

|---demo_file.py--

1)判断是否为文件

print os.path.isfile('test01')

>>False

print os.path.isfile('demo_file.py')

>>True

2)判断是否为目录

print os.path.isdir('test01')

>>True

3)判断是否为符号link

在linux里面会有一些link的文件

print os.path.islink('link_file')

4)判断文件或者目录是否存在

有的时候我们不在乎这个到底是文件还是路径，我们只关心它是否存在,有个简便的方法:

print os.path.exists('demo_file.py')

>>True

print os.path.exists('test01')

>>True

用Python写写文件的话，选你点击进去以后进行输入编码，或者是根据相关的一些方式进行抓取文档。