1.文件读写:
r’:读
‘w’:写
‘a’:追加
‘r+’ == r+w(可读可写,文件若不存在就报错(IOError))
‘w+’ == w+r(可读可写,文件若不存在就创建)
‘a+’ ==a+r(可追加可写,文件若不存在就创建)
‘rb’ ‘wb’ ‘ab’ ‘rb+’ ‘wb+’ ‘ab+’
加b是以二进制形式打开文件
读的方式:
f.read() 一次读所有 放入内存。当文件过大时,一起放入内存会出现内存占满的情况,因此只适用于读比较小的文件
for line in f.readlines() 一次读一行数据,放入内存
for line in f 一行一行读,且内存只保留一行数据,读下一行时释放上一行占用的内存。最好使用这种方式。
代码如下
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
product_list=[]
with open("F:/homework/day2/homeworkday2.txt") as f:
for line in f: # 一行一行读 且内存里只保存一行 最好用这种方式
product_list.append(list(line.strip('\n').split(',')))
# print(f.read())# 一次读所有都放进内存
# for line in f.readlines(): # 一次读一条 放入内存
# print(line)
2.集合
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
list_1 = [1,4,5,7,3,6,7,9]
list_1=set(list_1) # 变为集合 可以去重
print(list_1,type(list_1))
list_2 = set([2,6,0,66,22,8,4])
print(list_1,list_2)
# inrwesection 交集
print(list_1 & list_2)
print(list_1.intersection(list_2))
# 并集
print(list_1 | list_2)
print(list_1.union(list_2))
# 差集
print(list_1 - list_2) # 在1不在2
print(list_1.difference(list_2))
# 子集
list_3 = set([1,3,7])
print(list_3.issubset(list_3))
print(list_1.issuperset(list_3)) # 父集
# 对称差集
print(list_1 ^ list_2)
print(list_1.symmetric_difference(list_2)) # 并集-交集 symmetric 对称
list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4)) # 判断没有交集为true
# 没有插入只能添加
list_1.add(999)
print(list_1)
# 添加多项
list_1.update([99,11])
print(list_1)
# 删除
list_1.remove(1)
print(list_1)
# 长度 len(list_1)
# 判断成员
1 in list_1
1 not in list_1
3.字符串编码与转码
encode:编码就是将字符串转换为字节码,涉及到字符串的内部表示
decode:转码就是将字节码转换为字符串,是将比特位显示为字符
在所有环境下进行转码,列如utf8转gbk,都必须先decode为unicode再encode为gbk
为什么呢?
(注意:1.pyhton3 所有都是默认存的unicode。
pyhton3中头部定义的utf-8只是程序文件文本的编码。
2.因为unicode是集合了基本上所有语言的字符编码(ascii的扩展编码),想要转换都必须先decode为unicode再encode为目标编码
3.在python3中,encode后不但是转换了编码,并且还转换为byte类型。
)
例如:
一个字符串是utf-8,先encode转为二进制,再decode为unicode,在encode为gbk,这个时候这个字符串是gbk的编码,并且是一个byte类型,在将文本改为gbk编码的时候便能看到这个字符串编码后的内容。
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
import sys
print(sys.getdefaultencoding())
s = "你好" # 在这里 以上设置的utf-8只是文件编码,在python里所有都是用的unicode ,所以这里是unicode编码
s_to_gbk=s.encode("gbk")
print(s_to_gbk) # gbk
print(s.encode()) # utf8
gbk_to_utf8=s_to_gbk.decode("gbk").encode("utf-8") # 在python3中,encode不但转了编码还转换为byte类型
utf8_to_gbk=s.encode().decode("utf-8").encode("gbk") # 转码 先decode转为unicode 在这里unicode以byte类型显示 然后再ecode为gbk
print(gbk_to_utf8)
print(utf8_to_gbk)
# 字符串转字节码 encode 编码
# 字节码转字符串 decode 解码
4.编程范式
(1)函数编程
(2)函数式编程(只要输入是确定的,输出就是确定的,函数内部没有逻辑判断,代表语言,erlang)
(3).面向对象
函数与过程的区别
``
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
# 函数
def func1():
print('in the func1')
return 0
# 过程 相当于没有返回值的函数
def func2():
print('in the func2')
x=func1()
y=func2()
5.编程思想
面向对象和面向过程
6. 函数的参数
*args 是接收n个位置参数,转换为元组的形式
**kwargs 是接收n个关键字参数,转换为字典的形式
不管是定义函数的参数还是调用函数传入实参的时候,位置参数都必须在关键字参数之前。
在定义函数里的函数为形参,在调用函数时传入的函数为实参
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
def test(*args): # 接收n个位置参数,转换为元组的形式
print(args)
test(1,2,3,4,6)
test(*[1,2,3,4,5]) # *args=*[1,2,3,4,5]=
# 相当于 args = tuple([1,2,3,4,5])
def test1(x,*args):
print(x)
print(args)
test1(1,2,3,4,5,6,6,7)
# **kwargs 接收n个关键字参数转换为字典的方式
def test2(**kwargs):
print(kwargs)
print(kwargs['name'])
test2(name='yang',age=8,sex='F')
test2(**{'name':'yang','age':'12'})
def test3(name,**kwargs):
print(name)
print(kwargs)
test3('yang',age=18,sex='a')
def test4(name,age=18,**kwargs): # 参数组一定要往后放
print(name)
print(age)
print(kwargs)
test4('yang',hobby='tesla')
test4('yang',hobby='tesla',age=4)
test4('yang',3,hobby='tesla')
def test5(name,*args,age=18,**kwargs):
print(name)
print(age)
print(args)
print(kwargs)
test5('yang',3,age=4,hobby='tesla') # 位置参数必须在关键字参数之前
7.局部变量 全局变量
只有集合,列表,字典能够改全局变量,字符串、常量是不能改全局变量的(元组本身就不能改)
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
school="yhr" # 全局变量
names=["y","h","r"]
def chang_name(name):
global school
school = "yhr123"
print('before change',name,school)
name = 'yang' # 这个函数就是这个变量的作用域
print('after change',name)
names[0]="x"
print("names:",names)
name = 'y' # 全局变量
chang_name(name)
print(name)
print(school)
print(names) # 只有集合,列表,字典能够改全局变量,字符串、常量是不能改全局变量的(元组本身就不能改)
# 禁止以下写,容易导致逻辑混乱,不好调试,每一次调用都会改全局变量
# def change_name():
# global name # 可以变成全局变量,如果之前有就代替以前的全局变量
# name="y"
#
# change_name()
# print(name)
8.高阶函数
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
def add(a,b,f):
return f(a)+f(b)
res=add(3,-6,abs)
print(res)
9.递归函数
递归函数特性:
1.必须要有约束条件
2.每进入一层,问题规模要减少
递归效率不高,递归层次增多后,会导致栈溢出(函数是栈式存储的,每进行一次函数调用,3.增加一层栈帧,每返回一次值,减少
一层栈帧,由于栈不是无限大在内存中,当次数过多时,会导致栈溢出)
#!/usr/bin/env python
# coding:utf-8
# Author:Yang
#递归函数特性:
# 必须要有约束条件
# 每进入一层,问题规模要减少
# 递归效率不高,递归层次增多后,会导致栈溢出(函数是栈式存储的,每进行一次函数调用,增加一层栈帧,每返回一次值,减少
# 一层栈帧,由于栈不是无限大在内存中,当次数过多时,会导致栈溢出)
def cal(n):
print(n)
if int(n/2) > 0:
return cal(int(n/2))
print("->",n)
10.匿名函数
def func(x,y):return x+y
#相当于
lamda x,y:x+y