一 集合
1.集合是无序不重复的
2.集合操作:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
list_1 = set([1,3,4,5,6])
list_2 = set([1,5,11,23])
print("并集")
print(list_2.union(list_1))
print(list_1 | list_2)
print("交集")
print(list_1.intersection(list_2))
print(list_2 & list_1)
print("差集") # in list1 not in list2
print(list_2.difference(list_1))
print(list_2 - list_1)
print(list_1.difference(list_2))
print(list_1 - list_2)
print("对称差集")
print(list_2.symmetric_difference(list_1))
print(list_1 ^ list_2)
print("子集")
list_3 = set([3,6])
print(list_3.issubset(list_1))
print("父集")
print(list_1.issuperset(list_3))
print("是否有交集的方法,没有交集放回True否则返回False")
print(list_2.isdisjoint(list_3))
print(list_3.isdisjoint(list_1))
for x in list_1:
print(x)
print("****************************")
print("基本操作")
print("添加")
list_4 = set([9, 1, 2, 3, 4])
list_4.add(5) # 添加一项
print(list_4)
list_4.update([6, 7, 8]) # 添加多项
print(list_4)
print("使用remove可以删除一项,这项不存在的报错")
list_4.remove(8)
print(list_4)
print("len(s)长度")
print("x in s测试x是不是在s中,x可以是列表 字符 元组等")
print("pop删除任意一个")
list_4.pop()
print(list_4)
二 文件操作
1.文件操作流程:打开->操作->关闭
2.文件基本操作:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
print("文件基本操作")
# data = open("yesterday",encoding="utf-8").read()
# # data = open("yesterday").read()
# print(data)
f = open("yesterday","r",encoding="utf-8") #文件句柄
data = f.read()#第一遍读
data2 = f.read()# 此处是从第一遍读取结尾的地方开始读取。所以文件第一遍读取之后再读取就没内容了
print(data)
print("---------data2----%s---" % data2)
f.close()
print("写")
f2 = open("yesterday2","a",encoding="utf-8") #文件句柄
f2.write("我爱北京天安门\n")
f2.write("天安门上太阳升\n")
# data3 = f2.read() #不能读取
# print("-------data3:",data3)
f2.close()
print("*****************")
'''
模式:
w:是重新创建一个,之前的会覆盖
a:a = append,往后追加不覆盖原来内容,也不能读取
'''
f3 = open("yesterday","r",encoding="utf-8")
# for index,line in enumerate(f3.readlines()):
# if index == 9:
# print("------------------不打印----------------")
# continue
# print(line.strip())
'''
enumerate缺陷是先读到内存才开始循环,读取到内存需要时间等待,如文件太大会超过内存
所以enumerate只适合处理小文件
'''
# print("-----------*******------------")
# list1 = f3.readlines()
# for index in range(len(list1)):
# if index == 9:
# print("------------------不打印----------------")
# continue
# print(list1[index].strip())
#
print("高效取文件每行的方法")
print("-----------*******------------")
count = 0
for line in f3:
if count == 9:
print("------------------不打印----------------")
count += 1
continue
print(line.strip())
count += 1
f3.close()
f4 = open("yesterday","r",encoding="utf-8")
print("tell返回读取文件时候的指针,打印当前位置")
print(f4.readline())
print(f4.tell())
print("seek将指针设置指定位置")
f4.seek(4)
print(f4.readline())
print("打印编码格式")
print(f4.encoding)
print("fileno系统处理文件的接口编号")
print(f4.fileno())
print("seekable是否可移动指针")
print(f4.seekable())
print("readable文件是否可读")
print(f4.readable())
print("flush刷新存入硬盘")
print(f4.flush())
f5 = open("yesterday3","a",encoding="utf-8")
f5.seek(5)
# f5.truncate(10)#从文件开头截取 后面的删掉,seek失效
print("********文件的修改********")
print("r+:读写")
f6 = open("yesterday3","r+",encoding="utf-8")
print(f6.readline())
print(f6.readline())
print(f6.readline())
f6.write("\nr+读写操作\n")
print("w+:写读")
f7 = open("yesterday4","w+",encoding="utf-8")
f7.write("aaaa写读操作\n")
f7.write("aaaa写读操作\n")
f7.write("aaaa写读操作\n")
print(f7.tell())
f7.seek(10)
print(f7.readline())
f7.write("aaaaaaaaaaaaa\n")
f7.close()
print("a+:追加读写")
print("rb:二进制格式读文件。使用的情况:1网络传输 socket等 python3 只用用二进制 python2还可以用字符 2 打开对应的文件。二进制文件操作用对应的操作符")
f8 = open("yesterday4","rb")
print(f8.readline())
print(f8.readline())
print(f8.readline())
f9 = open("yesterday5","wb")
f9.write("Hello binary".encode())
print("文件的修改")
"""
1 vim
2 读取文件重新存入新的文件
"""
f10 = open("yesterday","r",encoding="utf-8")
f11 = open("yeterday6","w",encoding="utf-8")
for line in f10:
if "愚蠢的游戏" in line:
# line = "我享受生命 视其为快乐的游戏\n"
line = line.replace("我戏弄生命 视其为愚蠢的游戏","我享受生命 视其为快乐的游戏")
f11.write(line)
f10.close()
f11.close()
print("with数据,可以避免文件忘记关闭,自动关闭忘记")
with open("yesterday7","w",encoding="utf-8") as f1 ,\
open("yesterday8", "w", encoding="utf-8") as f2 :
f1.write("dddd")
f2.write("dddd")
3.flush立即更新写入的内容
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
import sys,time
for i in range(50):
sys.stdout.write("#")
sys.stdout.flush()
time.sleep(0.1)
三 字符编码解码
'''
https://www.cnblogs.com/alex3714/articles/5717620.html
unicode:中文英文字符都占2个字节,16位,万国编码。不同语言转换都需要通过Unicode
ASCII:只能存英文和特殊字符占1bytes,不能存中文字符
utf-8:所有的英文字符用ASCII表示占一个字节,中文占3个字节
ASCII 255 1bytes
|
unicode 2bytes
|
utf-8 en:1bytes zh:3bytes
问题是:中国游戏GBK游戏,到国外机器会乱码。怎么办?
unicode是所有的国家都支持,通过转换位unicode就可以
GBK(汉子内码拓展规范)转为UTF-8格式流程
1 GBK首先通过编码【decode】转换为Unicode的编码
2 然后通过解码【encode】转为UTF-8的编码
总结:
1 utf-8兼容Unicode,utf-8是unicode的扩展集
2 python3中默认所有字符都是Unicode,处理gbk需要改为# -*- coding:gbk -*-只是文件编码格式,但是代码还是Unicode
,python2.x要显示中文要写utf-8或者GBK
'''
s = "你好"
s_gbk = s.encode("gbk")
print(s_gbk)
print(s.encode()) #默认转为utf-8
gbk_to_utf8 = s_gbk.decode("gbk").encode("utf-8")
print(gbk_to_utf8)
四 局部跟全局变量
1. 全局变量在程序起始定义的。非常不建议在函数内修改全局变量而函数外没有定义此变量。当局部和全局同名时在子程序局部起作用,子程序之外还是全局起作用。
也就是说子程序修改全局变量,在子程序外是不被修改的。如果在子程序必须修改的话需要在变量名前加global
2. 全局变量列表和字典是可以修改的,其他不能。注意与第1点的区别
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
qjname = "JERRY"
def change_name(name):
#qjname = "JErrt11"#qjname是全局变量,在函数内修改全局变量,只有前面添加global qjname
global qjname
qjname = "JErrt11"
print("before change name:",name,qjname)
name = "Tom"#name是局部变量 这个函数就是这个变量的作用域
age = 23
print("after change name:", name)
name = "Jerry"
change_name(name)
print(name)
print(qjname)
#全局变量列表和字典是可以修改的,其他不能
names = ["Jerry","Tom"]
def change_name2():
names[0] = "JERRY"
print("insider func",names)
change_name2()
print(names)
五 函数
1. 编程的三种方式:
1) 面对对象:类->clasee
2) 面向过程:过程->def
3) 函数式编程:函数->def
可以当中三种不同门派,每个门派都有一个独特的秘笈。函数是逻辑结构化和和过程化的一种编程方法。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
import time
print("知识点1:过程跟函数")
print("函数的定义")
def func1():
"""testing"""#函数的文档说明
print("in the func1")
return 0
print("过程的的定义")
def func2():
"""testing2"""
print("in the func2")
'''
过程是没有返回值的函数,在python中x = func1()中x在接受func1的返回值
y = func2()中y则没有值是None
'''
x = func1()
y = func2()
print(x)
print(y)
print("************************")
print("知识点2:什么叫面向过程的编程方法")
'''
把逻辑模块放入一个def就可以
'''
print("知识点3:为什么使用函数")
"""
使用函数的好处:
1 代码重用
2 保持一致性
3 可扩展性
"""
def logger():
time_format = "%Y-%m-%d %X"
time_current = time.strftime(time_format)
with open("a.txt","a+") as f:
f.write("%s end action\n" % time_current)
def test1():
"""test1"""
print("test1 startting action....")
logger()
return 0
def test2():
"""test2"""
print("test2 startting action....")
logger()
return 0
def test3():
"""test3"""
print("test3 startting action....")
logger()
return 0
test1()
test2()
test3()
print("***********")
print("函数的返回值")
'''
1 无renturn:None
2 return有一个值,接受到就是该值
3 return个数类型都可以多个,多个返回成一个元组。实际还是一个值
'''
def fun1():
print("fun1")
return 0
print("test end")
x1 = fun1()
print(x1)
def fun2():
print("fun2")
def fun3():
print("fun3")
return 1,"Hello",["a","b"],{"name":"a"}
z = fun3()
print(z)
print("带参数的函数")
def ff(x ,y):
print(x)
print(y)
x = 1
y = 2
ff(y = 2,x = 1)
ff(1,2)#与形参一一对应
# ff(3,x = 1)#报错 x给了多个参数 关键参数一定要放在位置参数后面
print("练习: 关键字参数一定要放在位置参数后面")
def test_1(x,y,z):
print(x)
print(y)
print(z)
test_1(1,2,3)
test_1(x = 1,y = 2,z = 3)
test_1(1,z = 2,y = 5)
# test_1(1,4,y = 3)#会报错
# test_1(1,z = 4, 3)#会报错
print("**********")
print("默认参数:特点->默认参数在后面,调用时默认参数非必须传递")
def test_2(x = 2,y = 5):
print(x)
print(y)
test_2(1,2)
print("**********")
print("参数组 *args接受N个位置参数转换为元组")
def test_3(*args):
print(args)
test_3(1,2,3,5,6)
test_3(*[1,2,3,5,6])# args = tuple([1,2,3,5,6])
print("**********")
print("传字典")
#**kwargs把N个关键字参数转换为字典形式
def test_4(**kwargs):
print(kwargs)
test_4(name="Jerry",age=20,sex = "M")
test_4(**{"name":"Jerry","age" : 20,"sex" :"M"})
def test_5(name,**kwargs):
print(name)
print(kwargs)
test_5(name ="tom",name1="Jerry",age=20,sex = "M")
test_5(name ="tom")
test_5(name ="tom",age = 10)
print("test_6")
def test_6(name,age = 18,**kwargs):
print(name)
print(age)
print(kwargs)
test_6(name="tom", name1="Jerry", age=20, sex="M")
# test_6(name="tom",22,name1="Jerry", age=20, sex="M")
print("test_7")
def test_7(name,age = 18,*args,**kwargs):
print(name)
print(age)
print(args)
print(kwargs)
test_7("tom",20,2,3, name1="Jerry", sex="M")
2. 函数式编程
这里的函数是抽象很高的编程范式。只要输入确定输出也确定。如果想学函数式编程需要学lisp/hashshell/erlang都是纯函数式编程。
var result = substract(multiply(add(1,2)3),4)这就是函数式编程执行效率高/代码简洁。
但是最火的是面向对象编程
而传统的编程是:
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
3.递归函数:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
'''
递归函数:
在函数内部,可以调用其他函数,要是一个函数在调用的自身本身,这个函数就叫递归函数
特性:
1 必须有明确的结束条件
2 每次进入更深一层递归时,问题规模相比上次递归都应有所减少
3 递归效率不高。递归层次过多会导致栈溢出,因为栈的大小有限
'''
def calc(nun):
print(nun)
if int(nun/2) > 0:
return calc(int(nun/2))
print("->",nun)#只有条件不满足才会打印
x = calc(10)
4. 高阶函数:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Authon:Jerry Z
'''
变量可以指向函数,函数的参数能接收变量。那么一个函数就可以接收另外一个函数作为参数,
这就是高阶函数
'''
def add(a,b,f):
return f(a)+f(b)
res = add(1,-10,abs)
print(res)