一 集合的使用
集合是一个无序的，不重复的数据组合
1去重是集合的特点。把一个列表变成集合，就自动去重了。
2关系测试，测试两组数据之前的关系，例如交集、差集、并集关系。
__author__ = 'shellxie'
# -*- coding:utf-8 -*-
scg = [1,2,3,4,5,67,8,7,8]
scg= set(scg)
scg_1 = set([3,4,5,6,7,8,9,0])
print(scg,scg_1,type(scg)) # 集合是无序的
print(scg.intersection(scg_1)) # 取出交集
print(scg.union(scg_1)) # 求并集
print(scg.difference(scg_1)) # 求差集，我有你没有的就是差集，in scg not in scg_1
print(scg_1.difference(scg))
scg_2 =set([2])
print(scg_2.issubset(scg)) # 判断scg_2是不是scg的子集，返回为真
print(scg.issuperset(scg_2)) # 判断scg 是不是scg_2的父集，返回为真
print(scg.symmetric_difference(scg_1)) # 对称差集 ，把重复的去掉，然后合并
print(scg.isdisjoint(scg_1)) # 如果两个集合没有任何交集则返回为真
print(scg & scg_1) # 交集
print(scg | scg_1) # 并集
print(scg - scg_1) # 差集
print(scg ^ scg_1) # 对称差集
scg.add("我的是你") # 添加一项
scg.update(["德玛西亚","无极之道"]) # 添加多项
print(scg)
scg.remove("我的是你") # 删除一项
print(scg)
print(len(scg)) # 集合的长度
if "我的是你" not in scg: # 判断在不在
print("yeah")
print(scg.pop())
print(scg.pop()) # 删除一个任意的元素
print(scg)
print(scg.discard("我的是你")) # 删除一个集合中的元素，如果集合里真的有这个元素则删除，如果集合里没有这个元素，只会返回None。而remove的时候集合里没有这个元素的话，程序会报错。
二 文件操作
文件操作流程
1. 打开文件，得到文件句柄，并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件
文件操作增删改查
__author__ = 'shellxie'
# -*- coding:utf-8 -*-
# f = open("fivemiles").read()
# print(f)
# f = open("fivemiles") # 文件句柄
# scg =f.read()
# scg1 = f.read()
# print(scg)
# print("-----------scg1-------------",scg1) # 此时打印scg1 的时候 因为已经读过一遍了，内存指针停留在最后,所以再读的时候就是none输出
f =open("fivemiles","r") # r是读模式
f1 =open("fivemiles2","w") # w是写模式，创建一个文件，所以用的时候要慎重一点，会覆盖同名的文件
f1.write("我的剑就是你的剑\n")
f1.write("我的剑就是你的剑\n")
f2 = open("fivemiles2","a") # a是追加模式
f2.write("我的剑就是你的剑3")
#print(f2.read()) # a追加模式同样也不能读
print(f.readline()) # 读内存指针的所在那一行
print(f.readline())
print(f.readline())
print(f.readline())
print(f.readline())
for i in range(5): #用for 循环 来实现想读多少行就读多少行
print(f.readline())
print(f.readlines()) #把每行的东西作为一个元素放进一个列表,此时它是一个列表
print("---",f.readline()) #此时内存指针又到了最后的地方，再打印时已经是none
f3 = open("fivemiles3","r")
for index,line in enumerate(f3.readlines()):
if index ==9:
print("--------索引下标位9是说明已经打印了九行了--------")
continue
print( line.strip() ) # 比较耗费内存，需要把所有的读出来，是低级的循环
print("----------------------------------")
f4 =open("fivemiles4","r",encoding= "utf-8")
count =0
for line in f4:
if count==9:
print("我是分割线--------------------------------------")
count +=1
print(line)
count +=1
print(f4.tell()) # 此时光标在最后一个，所以打印的光标当前 的位置
f4.seek(0) # 将光标移到初始的位置
print(f4.tell())
f4.seek(10)
print(f4.readline()) # 从光标位置开始打印那一行
print(f4.encoding) # 打印编码
print(f4.fileno()) # 内部维护的一个编号
print(f4.name) # 文件名
print(f4.seekable()) # 不是所有的文件都能移动光标的，例如tty文件等等，能移动就返回True
print(f4.readable()) # 判断文件是否可读
print(f4.flush()) # 即时的刷新到硬盘中
import sys,time
for i in range(30):
sys.stdout.write("#") # 导入sys模块和time模块，stdout 是标准输出，标准输出写和即时刷新，0.1秒循环一次
sys.stdout.flush()
time.sleep(0.01)
print(f4.closed) # 判断文件是否关闭
f5 = open("fivemiles5","a",encoding="utf-8")
f5.seek(22)
f5.truncate() # 这个是受seek的影响的，alex在视频里说错了！
f6 = open("fivemiles6","r+") # 以读和追加的模式打开，不管光标在那里都是在文件最后追加
f7 = open("fivemiles7","w+") # 写读的模式打开，不管光标在那里都是在文件最后追加
f8 = open("fivemiles8","a+") # 追加读写
f9 = open("fivemiles9","rb") # 二进制的格式读这个文件
f10 = open("fivemiles10","wb") # 二进制的格式写
f10.write("hello \n".encode())
f11 = open("fivemiles11","ab") # 二进制的格式追加
print(f6.readline())
print(f6.readline())
print(f6.readline())
print(f6.readline())
f6.write("---------------我是分割线")
修改文件
f=open("fivemiles","r")
f_new =open("fivemiles2.bak","w")
str_find ="那就是我"
replace_str = "那就是alex1"
for i in f:
if str_find in i :
i = i.replace(str_find,replace_str) # 修改文件，源文件不动-创建一个新的
f_new.write(i)
f.close()
f_new.close()
with 语句
with open("fivemiles","r") as f,\
open("fivemiles2","r")as f1: # python 官方建议的with 打开多个文件的格式，因为一行最好不要超过80个字符
for line in f:
print(line)
三 字符编码与转码
中文的windows 默认是gb2312的编码
存一个英文字符或一个中文字符，unicode 所有的中文或者是英文都默认是占两个!
ASCII码里所有的英文字符都是占一个字节。ASCII码里是不能存中文的！！！
utf-8是一个可变长的字符编码，所有的英文字符依然是按照ASCII码的形式取存储，所有的中文字符统一是三个字节
unicode 相当于一个大袋子，里面装着GBK、GB2312、还有其他的。
在python3里所有的字符默认都是unicode
在python2里默认的编码格式是ASCII
四 Python函数介绍
1面向对象---华山派--->>>类--->>> class
2面向过程---少林派--->>>过程--->>> def
3函数式编程（最早的）---逍遥派--->>>函数--->>>def
编程语言中函数的定义：函数是逻辑结构化和过程化的一种编程方法。
python 中函数定义方法：
def test(x):
"值“
x+=1
return x
def :定义函数的关键字
test:函数名
（）：内可定义形参
“” :文档描述，非必要的内容，但是强烈建议添加描述信息，好让自己不要遗忘和别人知道你这里函数表达的意思，例如pycharm源码就描述了这个函数的意思
x+=1 :泛指代码或程序处理逻辑
return：定义返回值
#函数
def func1():
"testing1"
print("in the func1")
return 0
#面向过程 ：就是没有返回值的函数
def func2():
"testing2"
print("in the func2")
x=func1()
y=func2()
print(x,y)
#输出结果为：
in the func1
in the func2
0 None
一开始不懂return 0的意思 然后网上找了一下，这个知乎er对 return 解释的很到位，给各位新手也借鉴一下！以下为原文{
（首先要了解，函数是什么？
书上可能会说函数是完成功能的模块之类的话。其实说白了，函数就是个你招来的工人。
你给他一些材料，告诉他怎么用这些材料拼装，然后他负责把拼装好的成品交给你。材料就是函数的参数，成品是函数的输出，而怎么拼装就是你写的函数体代码了。
比如这段代码
def worker(a, b, c):
x = a + b
y = x * c
这个工人（worker）在你的指导下，用a b c三个材料，装配出了x和y两个成品。
但是程序里的装配和工厂不同，用过的材料不会消失。这样，这个工人手里就有了a b c x y五样物品。他怎么知道你要的是哪个呢？
所以return的作用就是，在这种时候告诉工人你到底想要什么东西，是一个iPhone手机壳还是整台iPhone。例如
def worker(a, b, c):
x = a + b
y = x * c
return y
这样工人就会把y交给你。当你让这个工人帮你干活（调用函数的时候）
result = worker(1, 2, 3)
你就会得到对应的结果（(1+2)*3）。
这就是return的作用。
作者：sqybi
def test():
print("in the test")
def test1():
print("in the test")
return 0
def test2():
print("in the test")
return 1,"ss",[1,2],{3:1,4:2}
test()
test1()
test2()
x=test()
y=test1()
z=test2()
print(x)
print(y)
print(z)
调用函数举例
__author__ = 'shellxie'
# -*- coding:utf-8 -*-
import time
def shopping():
"""this is shopping list"""
time_format = "%Y-%m-%d %X"
time_current = time.strftime(time_format)
with open("a.txt","a+") as f:
f.write("%s end action"% time_current)
product_list =[
("森海塞尔耳机",3880),
("高配大屏台式机",16880),
("捷安特自行车",3880),
("大床",6680),
("拿铁",38),
("苹果7p",5880)
]
salary = input("input your salary:")
shopping_list=[]
if salary.isdigit():
salary =int(salary)
while True:
for index,item in enumerate(product_list):
print(index,item)
choice= input("input the code that you wanna buy:")
if choice.isdigit():
choice=int(choice)
if choice<len(product_list) and choice>=0:
p_item =product_list[choice]
if p_item[1]<= salary:
shopping_list.append(p_item)
salary -=p_item[1]
print("add %s into you shopping list,and your 余额 is \033[40;1m %s \033[0m"%(p_item,salary))
else:
print("your 余额 is \033[40;1m not enough \033[0m to buy,please 跟我学python吧")
else:
print("correct number please")
elif choice == "q":
print("------SHOPPING CART------")
for p in shopping_list:
print(p)
print("你的余额还剩 \033[41;1m %s \033[0m"%salary)
exit()
else:
print("Only \033[40;1m Number \033[0m Please") #42代表背景绿 41代表背景红 40 代表背景黑色
else:
print("\033[42;1m ONLY NUMBERS PLEASE\033[0m")
def test():
print("购物车")
shopping()
test()
函数参数
def test(x,y): # x和y是形参
print(x)
print(y)
test(1,2) # 1和2 是实参
test(x=1,y=2) # 关键字参数调用，与形参顺序无关
test(1,2) # 位置参数调用，与形参一一对应
test(2,y=3) # 关键参数不能写在位置参数前面
默认参数
def test(x,y=2): # 默认参数的特点：调用函数的时候，默认参数非必需传递的。也就是说形参如果有值了，在实参里面你不写，是可以的，函数调用的时候就直接用默认的形参！
print(x) # 用途是 1.默认安装值 2.
print(y)
test(1)
test(1,3) # 但是如果实参写了，调用函数的是会以实参为准
*agrs 和 **args 的应用
#args 只能接收n个位置参数，然后转化成元组的形式
def test(*args):
print(args)
test(1,2,3,4,56,7,6)
test(*[1,2,3,4,5,6,7])
test(*[1,2,3,4,5,6]) # args = tuple ([1,2,3,4,5])
print("------------")
def test1(x,*args): # *args 会把多传入的参数变成一个元组形式
print(x)
print(*args)
test1(1,2,3,4,5,6,7)
# **kwargs 只能把n个关键字参数，转换成字典的方式,一定要是关键字参数
def test(**kwargs): # **代表接收字典
print(kwargs)
print(kwargs["name"])
print(kwargs["age"])
test(name="alex",age=22,sex= "f") # 把关键字参数按照字典的方式存放起来
test(**{"name":"alex","age":8})
def test (name,age,*args,**kwargs): # 输出结果
print(name,age,args,kwargs) # Alex 22 () {}
test("alex",32) # 后面这个{}就是kwargs,只是因为没传值,所以为空
test("alex",32,"cn","python",sex="male",province= "anhui")
作用域、局部与全局变量
school = "SCG" # 全局变量 ,能用在这里的任何地方
def change_name(name):
global school # 在函数里把局部变量修改成全局变量
school = "ShiDao"
print("before chagne ",name,school)
name = "SHELL" # 这里的name 就是局部变量，而这个函数就是这个变量的作用域
print("after chagne",name)
print(school) # 这里的打印scholl 是函数没调用之前
name = "alex"
change_name(name)
print(name)
print(school) # 这里打印的school 是把函数里的局部变量改成了全局变量之后
递归
在函数内部可以调用其他函数。如果调用自己本身，这个函数就是递归函数。
1 递归必须有一个明确的结束条件
2 每次进入更深一层的递归是，问题的规模比上次递归的都应该有所减少
3 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
def alex(n):
print(n)
if int(n/2) >0 :
return alex(int(n/2)) # int的功能是把他转化成整数
print(">>>>>",n)
alex(10)
函数式编程介绍
数学里面的函数，输入是确定的，输出是一定确定的。但是在我们python函数里面。输入是确定的，而输出是不一定确定的
例如
#f(x,y) , z= 3x+2y #这个是数学里面的二元函数，如果输入是固定的，输出也就是固定的
def scg(x,y) : # 因为存在逻辑运算，所以输出不是固定的
if x +y > 9:
return 0
scg(2,6)
print(scg(2,6))
函数是编程语言去学 lisp,hashshell,erlang
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就可以称为高阶函数。
def add(a,b,f): # 高阶函数，abs 是一个求绝对值的内部自定义函数
return f(a) + f(b)
print( add(3,-6,abs)
)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
