Python学习-初学入门3

一 集合

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)