python学习-day3
今天是第三天学习，加油！
第一部分 集合
一、集合
1.什么是集合以及特性？
特性：无序的，不重复的序列，可嵌套。
2.创建集合
方法一：创建空集合
s1 = set() print(type(s1))
结果： 可以看出来创建的是集合类型的。
方法二：
s1 = {"123","456"}
print(s1)
print(type(s1))
结果：
方法三：列表转换为集合
list1 = [11,22,11,22] s1 = set(list1) print(s1)
结果：从结果可以看出来集合的特性：无序和不重复的特点
方法四：把字典转换为集合
1.把字典的key转换为集合
dict1 = { "key1":11, "key2":22, "key3":33, } set_dict1 = set(dict1) print(set_dict1)
结果：
从结果可以看出来，默认是把字典的key转换为集合了。
2.把字典的key转换为集合
set(dict1.keys())
dict1 = { "key1":11, "key2":22, "key3":33, } set_dict1 = set(dict1.keys()) print(set_dict1)
结果：
从结果可以看出来，使用dict1.keys() 和set结合，也可以把字典的key转换为集合。
3.把字典的value值转换为集合
set(dict1.values())
dict1 = { "key1":11, "key2":22, "key3":33, } set_dict1 = set(dict1.values()) print(set_dict1)
结果：
从结果可以得出，使用dict1.values和set集合，可以把字典的value值转换为集合。
所以从以上关于字典的3个例子中可以得出结论：
结论：
1.字典转换为集合时，使用set（dict1()） 默认是把字典的key转换为集合；
2.使用 set(dict1.keys()) ，也可以把字典的key转换为集合；
3.使用set(dict1.values()) ，可以把字典的value转换为集合；
二、集合的操作
1.集合添加元素
add()
一次只能添加一个元素
s1 = set() s1.add(123) print(s1)
结果：
1.1 看看这个例子
s1 = set() s1.add(123) s1.add(123) s1.add(123) print(s1)
结果：
为什么两个例子的结果完全一样？ why？
这两个例子的结果完全体现出了集合的特性：不重复！所以第二个例子虽然执行了3次 s1.add(123) ，但是结果只有一个 {123}
2.集合批量添加元素（迭代添加）
update()
s1 = set() list1 = [11,22,33,44] #update接受一个可以被迭代的对象，也就是可以被for循环的。update相当于调用多次add函数 s1.update(list1) print(s1)
结果：
3.集合A中存在，集合B中不存在
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.difference(s2)
print(s3)
结果：
{11}
4.集合的对称差集
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.symmetric_difference(s2)
print(s3)
结果：
{11, 44}
5.difference_update 的使用，这样就不用定义第三个变量了。
s1 = {11,22,33}
s2 = {22,33,44}
s1.difference_update(s2)
print(s1)
结果：
{11}
6. s1.symmetric_difference_update()使用和difference_update类似
s1 = {11,22,33}
s2 = {22,33,44}
s1.symmetric_difference_update(s2)
print(s1)
结果：
{11, 44}
7.集合元素的移除
方法一：discard()
s1 = {11,22,33}
s1.discard(11)
print(s1)
结果：
{33, 22}
方法二：
remove()
s1 = {11,22,33}
s1.remove(11)
print(s1)
结果：
{33, 22}
对比：discard() 与 remove()的区别
s1.discard(1111) #移除的不存在元素不会报错,最常用
s1.remove(1111) #移除的值不存在的元素 会报错
方法三：
随机移除一个元素
s1 = {11,22,33}
ret = s1.pop() #随机移除一个元素，并打印被移除的元素
print(ret)
8.集合的交集
intersection() 与 intersection_update()
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.intersection(s2)
print(s3)
s1.intersection_update(s2)
print(s1)
结果：
{33, 22}
{33, 22}
9.集合并集
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.union(s2)
print(s3)
结果：
{33, 22, 11, 44}
第二部分：函数
一、函数的定义
1.什么是函数？
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
2.为什么要使用函数？
以前我们写的python或者bash 脚本都是面向过程的。即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处。
这样的缺点很明显，代码重复性高，可读性差等等。
3.函数的定义
定义函数，函数体不执行，只有调用函数时，函数体才执行
函数的定义规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
函数的几个名词解释：
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
语法：
def functionname( parameters ): "函数_文档字符串" function_suite return [expression]
默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
二、函数的返回值：
1.默认返回值
def A(): print(123) return #不写return 返回的也是None R = A() print(R)
结果：可以看出来默认返回的是 None，不写return 也会返回None
2.指定返回值
def A(): try: print(123) except: return False #操作失败会执行except else: return True #代码执行成功后，执行else：下的return R = A() print(R)
结果：
3.怎么利用返回值
一般我们使用函数的返回值去做一些判断操作
def A(): try: print(123) except: return False #操作失败会执行except else: return True #代码执行成功后，执行else：下的return R = A() print(R) if R == True: print("OK") else: print("ERROR")
结果：
4.在函数中，一旦执行return，函数执行过程立即终止
def A(): print(123) return 222 ##在函数中，一旦执行return，函数执行过程立即终止 print(456) R = A() print(R)
结果：发现没有执行 print(456)命令
三、函数的执行顺序
python是从上到下的顺序执行，但是函数体的内容，只有调用函数时才会执行。
三、函数的参数：
1.普通参数：严格按照顺，将实际参数赋值给形式参数
2.默认参数：必须放置在参数列表的最后
3.指定参数：将实际参数赋值给指定的形式参数
4.动态参数：
* 默认将传入的参数，全部放置在元组中，f1(*[11,22,33,44])
** 默认将传入的参数，全部放置在字典中，f1(**{"k1":"v1","k2":"v2"})
5.万能参数：*args , **args
注意：
def send(user,content,xx): print(user,content,xx) send("user1:","hello","ok")
结果：
2.默认参数：
注意：默认参数必须放在参数列表的最后面，例如下面的xx = "OK" 放到了参数列表的后面
def send(user,content,xx="OK"): print(user,content,xx) send("user1:","hello","FFFF") send("user1","hello")
结果：
从结果可以得出：xx = "OK" 就是默认参数，如果给xx指定了参数值，那么xx 就是指定的值。例如：上面指定了 FFFF
如果不指定参数值，那么xx就用默认的Ok值。例如：send("user1","hello") 这个没有为xx指定参数值。
3.指定参数：
def send(user,content): print(user,content) send(content="hello", user = "user1")
结果：
可以通过content="hello" 把hello赋值给content变量，可以通过user = "user1"，把user1赋值给user变量，这就是指定变量。
4.动态参数*args
def f1(*args): print(args,type(args)) list1 = [11,22,"alex","hehe"] f1(list1,'name')
结果：
由结果可以知道，我们传的参数，都会作为元组的一个元素，例如：列表list1=[11,22,'alex','hehe'] ，list1作为了 元组的一个元素，参数name也作为了元组的一个参数。
def f1(*args): print(args) list1 = [11,22,"alex","hehe"] f1(list1) #把整个列表内容当成一个整体作为元祖的一个元素
结果：
从结果可以知道，把参数list1（列表），当成了一个整体作为元组的一个元素
def f1(*args): print(args) list1 = [11,22,"alex","hehe"] f1(*list1) # 把列表中的每个值，分别作为元祖的每个元素
结果：
从结果可以知道：这个例子中，把参数list1（列表）的每个元素，分别作为元组的每一个元素来处理
5.动态参数 **args
5.1 使用key=value的形式传送变量和值
def f1(**args): print(args,type(args)) f1(n1="test",n2=30)
结果：
**args 参数是把传送过的值当作字典。
5.2 传的字典参数，还是按照字典来处理
def f1(**args): print(args,type(args)) dict1 = {'k1':"v1",'k2':"v2"} f1(**dict1)
结果：
从结果可以知道，把字典的值传给**args后，也是按照字典的形式处理。
5.3 把整个字典作为value处理
def f1(**args): print(args,type(args)) dict1 = {'k1':"v1",'k2':"v2"} f1(kk=dict1)
结果：
从结果可以看出来：kk是整个字典的key，而dict1作为一个整体成为kk的value值；
6.万能参数：
def f1(*args,**kwargs): print(args) print(kwargs) f1(11,22,33,44,k1="v1",k2="v2")
结果：
从结果可以得到：*args 是按照元组来处理。**args 是按照字典来处理的。
11,22,33,44 传给*args 处理。 k1="v1",k2="v2" 传给**args来处理。
四、全局变量
1.全部变量特性：
- 全局变量必须使用大写（这是python开发者的潜规则）
- 全局变量，所有作用域都可读
- 对全局变量进行【重新赋值】，需要global
- 特殊：列表字典，可修改，但是不可以重新赋值
2.对全局变量进行【重新赋值】，需要使用global
NAME = "test" def f1(): age = 18 global NAME #表示，NAME是全局变量。 NAME = "123" print(age,NAME) def f2(): age = 19 print(age,NAME) f1() f2()
结果：全局变量NAME的值test 被修改为123
3.特殊：列表字典，可修改，但是不可以重新赋值
NAME = [11,22,33,44] def f1(): NAME.append(9999) #可以修改 print(NAME) f1()
结果：列表NAME中已经增加了元素 9999
第三部分 字符串与字节的互相转换
# utf-8 一个汉字：三个字节
1.字符串转换为字节
格式
bytes(要转换的字符串， 按照什么编码）
s = "百度" n = bytes(s,encoding="utf-8") print(n)
结果：
可以看到，一个汉字在utf-8类型中是占用3个字节
下面看下载gdk编码中：
s = "百度" n = bytes(s,encoding="gbk") print(n)
结果：
可以看出，在gbk编码中，一个汉字占2个字节
2.字节转换为字符串
使用str()
new_str = str(bytes("百度",encoding="utf-8"),encoding="utf-8") print(new_str)
结果：
百度
http://i.cnblogs.com/EditPosts.aspx?postid=5516664
第四部分 文件操作
一、打开文件
语法：
文件句柄 = open('文件路径','模式')
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。
f = open('db','r') #只读模式【默认】 f = open('db','w') #只写模式【不可读；不存在则创建；存在则清空内容；】 f = open('db','x') #只写模式 【不可读；不存在则创建，存在则报错】 f = open('db','a') #追加模式 【可读；不存在则创建；存在则只追加内容】 f = open('db','r',encoding="utf-8")
以上只是以字符串来进行操作。
如果使用 “b” 参数，表示以字节来操作，例如 wb,rb,ab ，都是以字节为单位来操作的。
“+” 表示可以同时读写某个文件
- r+，读写【可读，可写】
- w+，写读【可读，可写】
- x+，写读【可读，可写】
- a+，写读【可读，可写】
“b” 表示以字节的方式操作
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
注意：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
read() 方法读取文件内容：
无参数，读全部；
如果打开模式无b，则read，按照字符读取。如果有b，则按照字节读取
2.seek()调整当前指针的位置（字节）
seek() 永远是以字节的形式移动位置。不管我们是以什么样的形式打开文件，都是以字节的形式移动位置。
3.tell()获取当前指针的位置（字节）
以字节的形式获取位置
例如：
文件db的内容为：
国admin 123456
f = open("db",'r+',encoding="utf-8")
#如果打开模式无b，则read，按照字符读取 data = f.read(1) print(f.tell()) f.close()
结果：
3
因为在utf-8编码中一个汉字是3个字节。所以这里的结果是3
4.flush() 强制把内容写入到硬盘
5.readline() 仅读取一行
6.for循环文件对象（迭代文件内容）
f = open("db",'r+',encoding="utf-8") for line in f: print(line)
7.with open('file1') as file1 , open('file2') as f2:
把file1文件中的前10行，写入一个新文件file2里
with open('file1','r',encoding="utf-8") as f1,open('file2','w',encoding="utf-8") as f2: times = 0 for line in f1: times += 1 if times < 10: f2.write(line) else: break
8.把file1文件中的某个字符串替换为别的字符串，并生成一个新文件file2
下面的例子中，把关键字 baidu 替换为 google
with open('file1','r',encoding="utf-8") as f1,open('file2','w',encoding="utf-8") as f2: for line in f1: new_str = line.replace("baidu",'google') f2.write(new_str)
