1.集合:

集合的创建:

list_1 = set([1,2,3,4,5])
list_2 = set([2,3,44,7,8])

集合的特性:集合是无序的,集合可以去掉重复的元素

集合的操作:
求交集:

print(list_1.intersection(list_2)) #{2,3}
print(list_l & list_2) #求交集,{2,3}

求并集:

print(list_1.union(list_2)) #{1,2,3,4,5,7,8,44}
print(list_l | list_2) #求并集,{1,2,3,4,5,7,8,44}

求差集:

print(list_1.defference(list_2)) #in list_1 but not in list_2,{1,4,5}
print(list_l - list_2) #求差集,in list_1 but not in list_2:{1,4,5}

判断子集:

print(list_1.issubset(list_2)) #list_1是否是list_2的子集,None

判断父集:

print(list_1.issuperset(list_2)) #list_1是否是list_2的父集,None

对称差集:

print(list_l.symmetric_difference(list_2)) #对称差集,并集里面去掉交集,{1,4,5,7,8,44}
print(list_l ^ list_2) #对称差集,并集里面去掉交集

判断交集:

print(lsit_1.isdijoint(list_2)) #Yes

增加:

lsit_3 = set([1,2,3,4])
#单个增加:
list_3.add(5)
#多个增加:
list_3.update([6,7,8,9])

删除:

 删除:list_3.remove(1)
print(list_3.pop()) #随机删除

求集合的长度:
print(len(list_3))

2.文件

文件的创建:

f = open("yesterday","w",encoding="utf-8")
'''
#with语句,为了避免打开文件后忘记关闭,可以通过管理上下文,即:
with open("log","r") as f:
pass
#python2.7之后,with有支持同时对多个文件的上下文进行管理,即:
with open("log1") as obj1,open("log2") as obj2:
psss
'''
#开发规范:一行不得超过八十个字符
with open("yesterday2","r",encoding="GB18030") as f,\
open("yesterday","r",encoding="GB18030") as f2:
for line in f:
print(line.strip())

文件的操作:
读:

f = open("yesterday","r",encoding="utf-8")#不可写
data = f.read()
print(data) #输出文件的内容
list = f.readlines()
'''
#将硬盘中的数据全部读入内存中形成一个列表,并且自动添加了换行符. ['我爱北京天安门,\n', '天安门上太阳升\n', '我爱北京天安门\n']
'''
print(f.readline()) #一行一行地读
#循环读:
for line in f:
print(line)

写:

f = open("yesterday","w",encoding="utf-8")
#不可读,每运行一次就会创建一个新的文件覆盖掉原来的文件
f.write("sladjla")

追加:

f = open("yesterday","a",encoding="utf-8")#不可读
f.write("sldad")

句柄位置操作:

print(f.tell()) #打印句柄位置
f.seek(5) #使句柄回到某个位置
print(f.encoding) #打印文件的编码
print(f.fileno()) #返回文件编号
print(f.name) #打印文件名字
print(f.isatty()) #判断是否为终端设备 True、False
print(f.seekable()) #判断句柄是否可移 True、False
print(f.readable()) #判断文件是否可读 True、False

刷新:

f.flush()#刷新,将内存中的内容一次性刷入硬盘中
import sys,time
for i in range(50):
sys.stdout.write("#")
sys.stdout.flush()
time.sleep(0.1)

读写、写读、追加的、二进制读写:

f = open("yesterday2","r+",encoding="GB18030")#读写模式,不会清空原文件
f = open("yesterday2","w+",encoding="GB18030")#写读模式,会清空原文件
f = open("yesterday2","a+",encoding = "GB18030")#追加读
f = open("yesterday2","rb或者wb") #二进制文件
print(f.readline())
print(f.readline())
print(f.readline())
print(f.tell())
f.write("\n------diao------") #只能添加在末尾
print(f.readline())
#文件操作的二进制读写
f = open("yesterday2","rb")
print(f.readline())#b'\r\n'
f = open("yesterday2","wb")
f.write("hello binary".encode())#只能写入二进制格式
'''
"U"表示在读取时,可以将\r \n \r\n自动转换为\n(与r或r+模式同时使用)
> rU
> r+U
'''

文件修改:

f = open("yesterday","r",encoding="GB18030")
f_new = open("yesterday3","w",encoding="GB18030")
for line in f:
if "poj" in line:
line = line.replace("poj","急急急急急急")
f_new.write(line)
f.close()
f_new.close()

3.字符编码与转换:

GBK--decode-->unicode【中间站】--encode-->utf-8
utf-8--decode-->unicode【中间站】--encode-->GBk
GBK转换为utf-8流程:
1.首先通过编码【decode】转换为Unicode编码
2.然后通过解码【encode】转换为utf-8编码
utf-8转换为GBK流程:
1.首先通过编码【decode】转换为Unicode编码
2.然后通过解码【encode】转换为utf-8编码 utf-8是Unicode编码的扩展集,故在utf-8程序中,Unicode格式可以直接打印
但是GBK编码不能在Unicode程序中直接打印,即使Unicode兼容GBK编码 在python2中解释器默认是ASCII码
python3中解释器默认是unicode编码
在python3中进行转码、编码会自动转成二进制类型
s = "你好"
s_gbk = s.encode("gbk")
print(s_gbk)#b'\xc4\xe3\xba\xc3'
print(s.encode())#b'\xe4\xbd\xa0\xe5\xa5\xbd'
gbk_to_utf8 = s_gbk.decode("gbk").encode("utf-8")
print(gbk_to_utf8)#b'\xe4\xbd\xa0\xe5\xa5\xbd'
s = "你哈"
print(s.encode("gbk")) #b'\xc4\xe3\xb9\xfe',因为解释器默认是Unicode编码
print(s.encode("utf-8")) #b'\xe4\xbd\xa0\xe5\x93\x88'
print(s.encode("utf- 8").decode("utf8").encode("gb2312").decode("gb2312"))#你哈

4.函数与函数式编程:
编程方法:
1.面向对象

2.面向过程

3.函数式编程

函数定义:

函数式逻辑结构化和过化的一种编程方法

python中函数定义的方法:

def text(x):
"The function definition"
x += 1
return x
''''
def:定义函数中的关键字
text:函数名
():内可定义形参
"":文档描述(非必要,但是强烈建议为你的函数添加描述信息)
x += 1:泛指代码或程序处理器
return:定义返回值
''''

使用函数的优点:
1.避免了大量代码的重复使用

2.保持一致性:修改函数中的代码,在所有使用函数的地方都会改变

3.可扩展性(一致性)

                         import time
def logger():
time_format = "%Y=%m-%d %X"
time_current = time.strftime(time_format)
with open("hahaha","a+",encoding="utf-8") as f:
f.write("%send action\n"%time_current)
def text1():
print("in the tex1")
logger()
def text2():
print("in the tex2")
logger()
def text3():
print("in the tex3")
logger()
text1()
text2()
text3()

函数和过程:

过程定义:过程就是简单没有返回值的函数

总结:一个函数/过程没有使用return显性的定义返回值时,python解释器会隐式返回None,所以在python中即便是过程也可以算作是函数

                         #函数:
def func1():
"testing1"
print("in the func1")
return 0
#过程:
def func2():
"testing2"
print("in the func2")
x = func1()
print("from func1 return is %s "%x) #from func1 return is 0
y = func2()
print("from func2 return is %s"%y) #from func2 return is None
#当一个函数/过程没有使用return显性的定义返回值时,python解释器会隐式返回None,
#所以在python中即便是过程也可以算作函数

函数返回值:

返回值数=0,返回None
返回值数=1,返回object
返回值数>1,返回tuple

                        def text1():
print("in the text1")
'''
return 0 #结束函数,并返回一个值
print("text end") #不会执行
'''
def text2():
print("in the text2")
return 0
def text3():
print("in the text3")
  return 1,"hello",["alex","wupeiqi"],{"name":"alex"}
x = text1()
y = text2()
z = text3()
print(type(x),x) #<class 'NoneType'> None
print(type(y),y) #<class 'int'> 0
print(type(z),z) #<class 'tuple'> (1, 'hello', ['alex', 'wupeiqi'], {'name': 'alex'})

函数调用:test()执行,()表示调用test,()可以有参数也可以没有

参数:

1.形参和实参:
       形参:形式参数,不是实际存在的,是虚拟变量。在定义函数和函数体的时候使用形参,目的是在函数调用时接受实参(实参个数、类型因该与形参一一对应)
       实参:实际参数,调用函数时传给函数的参数,可以是常量、变量、表达式、函数传给形参
       区别:形参时虚拟的,不占用内存空间,形参变量只有在被调用时才分配内存单元,实参是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参
2.位置参数和关键字参数(标准调用:实参和形参位置一一对应;关键字调用:位置无需固定)

                        #标准调用,实参与形参一一对应
def test1(x,y):
"x、y是位置参数"
print("in the test1:")
print("x = %s\ny = %s"%(x,y))
test1(2,1) #实参跟形参必须一一对应
#关键字调用,与形参顺序无关
def test2(x,y):
print("in the test2:")
print("x = %s\ny = %s"%(x,y))
test2(y = 1,x = 2)
#test2(x = 2,3) error
#test2(3,y = 2) OK
#因此关键字参数不能位于位置参数的前面

3.默认参数:特点:调用函数的时候,默认参数非必须传递

                        def test(x,y=2):
print(x)
print(y)
test(x = 1,y = 3) #OK
test(1) #OK
#test(y = 3) error
#特点:调用函数的时候,默认参数非必须传递

4.参数组

                        def test(*args):
print(args) test(1,2,3,4,5) #(1, 2, 3, 4, 5)
test(*[1,2,3,5,5]) #args = tuple([1,2,3,5,5]):(1, 2, 3, 5, 5)
def test1(x,*args):
print(x)
print(args)
test1(1,2,3,4,5,6,34,3) #
#*args是接收N个位置参数,转换成元组的方式 (2, 3, 4, 5, 6, 34, 3)
#**kwargs:是就收N个关键字参数,转换成字典的方式;传递字典
def test2(**kwargs):
print(kwargs)
test2(name = "alex",age = 22,sex = "N") #{'name': 'alex', 'age': 22, 'sex': 'N'}
def test3(name,*args,**kwargs):
print("the information of %s:"%name)
print(kwargs)
print("%s like the numbers:%s"%(name,args))
test3("alex",3,7,21,age = 19,sex = "m")
#def test4(name,**kwargs,age=18) error,默认参数必须放在参数组的前面
#def test4(name,age=18,**kwargs) OK

注意:1.关键字参数必须位于位置参数的后面 2.默认参数必须放在参数组的前面

前向引用:

函数action体内嵌套某一函数logger,该logger的声明必须早于action函数的调用,否则报错

全局变量与局部变量:

在子程序中定义的变量称为局部变量,在程序一开始定义的变量称为全局变量。
全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序
当全局变量与局部变量冲突时:
在定义局部变量的子程序内,局部变量会屏蔽掉全局变量,在其他地方全部变量起作用

                         school = "Oldboy edu" #全局变量
def change_name(name):
"这个函数就是其内部即局部变量的作用域"
global school #将school改为全局变量
school = "mage linux"
print("school:",school)
print("before change:",name)
name = "Alex li"
print("after change:",name)
name = "alex"
change_name(name)
print(name)#alex
print("shcool:",school)#shcool: mage linux
#一般来说,我们不应该在函数内部将局部变量改为全局变量
因为这样在无数次调用这个函数后,我们很难知道实在哪儿将变量修改了
故我们不应该使用这种方法:
def change_name():
global name
name = "alex"
change_name()
print(name)
#附注:列表、字典是可以在函数中修改的

高阶函数:

变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就叫高阶函数

                        def abs(x):
if x>=0:
return x
else:
return -x
def add(a,b,f):
return f(a)+f(b)
print(add(3,-6,abs)) #

递归:
定义:如果一个函数在内部调用自己本身,这个函数就是递归函数

特性:
1.必须有一个明确的结束条件

2.每次进入更深一层循环时,问题规模相比上次递归有所减少

3.递归效率不高,递归层次过多时回导致栈溢出

def cal(n): 
print(n)
if int(n/2)>0:
return cal(int(n/2))
print("---->",n)
cal(10)

python第三周:集合、函数、编码、文件的更多相关文章

  1. Python第三周 数据类型:集合set、文件的读写、追加操作。

    集合 知识点:集合是无序的 格式:{1,2,3,"str_test"} set_1 = set(list1)#将列表转换为集合 集合关系测试: 集合的逻辑判断.取交集.并集.差集. ...

  2. python day5 lambda,内置函数,文件操作,冒泡排序以及装饰器

    目录 python day 5 1. 匿名函数lambda 2. python的内置函数 3. python文件操作 4. 递归函数 5. 冒泡排序 6. 装饰器 python day 5 2019/ ...

  3. python第三章:函数

    在前面章节中,介绍了一些input(),print(),len()等内建函数,还有random,math等标准库相关函数,这些都是可以直接使用的,但是很多时候,我们也是可以编写自己的函数. 看个例子: ...

  4. Python(三)enumerate函数

    原文链接:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143177932 ...

  5. python第三周文件处理和函数-----下

    #默认参数的值是在一开始定义的时候就传给了函数, # 在后来的修改中不会被修改. #默认参数的值必须放到位置形参参数的最后面 #默认参数使用的场景是一个参数不经常变得场景,所以参数一般是不可变类型.字 ...

  6. python基础三(集合、文件)

    1.集合定义 集合天生能去重,且与字典一样,无序.集合用大括号括起来,里面的元素之间用逗号分隔,要跟字典区分开. 集合定义方法:s=set() #定义一个空集合 s={'1','a','b','c', ...

  7. 人生苦短我用Python 第三周 函数周

    函数的定义: 1,def 函数名(参数1,参数2......): "注释:函数的作用和参数,增加可读性", 2,函数体 3,返回值 最简单的函数: def func(): prin ...

  8. python第二周数据类型 字符编码 文件处理

    第一数据类型需要学习的几个点: 用途 定义方式 常用操作和内置的方法 该类型总结: 可以存一个值或者多个值 只能存储一个值 可以存储多个值,值都可以是什么类型 有序或者无序 可变或者不可变 二:数字整 ...

  9. Python第三周 函数详解

    def 函数名(): """注释说明"""" 执行逻辑体 return 返回值 定义不带参数的函数 带参数的函数 默认参数 这个是 ...

随机推荐

  1. 链表快排 & 基于链表的排序

    以前只知道链表做插入(朴素.非二分)排序挺方便的.现在知道了(单)链表进行快速排序也是很好的(只是跟一般的快排的方式不一样). 参考: http://blog.csdn.net/otuhacker/a ...

  2. win7/WIN8.1(x64) 下使用MSDE WIN10不行

    通过强制安装(使用管理员权限),手工启动服务的方式,能够在其win7 win81上安装并使用MSDE Microsoft SQL Server 2000 Service Pack 4 Desktop ...

  3. &lt;图形图像,动画,多媒体&gt; 读书笔记 --- 录制与编辑视频

    使用UIImagePickerController 进行录制 #import "ViewController.h" #import <MobileCoreServices/M ...

  4. 设计一部iphone手机用面向对象的方法

    main.m //编辑字体大小command + < //编译执行快捷键 com + R #import <Foundation/Foundation.h> #import &quo ...

  5. Node.js:教程

    ylbtech-Node.js:教程 1.返回顶部 1. Node.js 教程 简单的说 Node.js 就是运行在服务端的 JavaScript. Node.js 是一个基于Chrome JavaS ...

  6. 省市区js三级联动(原创)

    看了一些网上的js三级联动,但感觉不是缺这,就是少那,决定亲自操刀写了一个,现记录如下,以备后用! <!DOCTYPE html> <html> <head> &l ...

  7. Prism学习(1)---前期准备

    本文摘取自Gene's Blog的博客园文章,版权归Gene's Blog,仅供个人学习参考.转载请标明原作者Gene's Blog. 在学习Prism框架之前,我预先写了一个非常简单的计算器解决方案 ...

  8. Codeforces Round #449

    960  asteri 1384     492 00:04 -1 892 01:33     960 PEPElotas 1384     488 00:06 896 00:26       960 ...

  9. javascript的基础知识及面向对象和原型属性

    自己总结一下javascript的基础知识,希望对大家有用,也希望大家来拍砖,毕竟是个人的理解啊 1.1 类型检查:typeof(验证数据类型是:string) var num = 123; cons ...

  10. 【Oracle】DBMS_STATS.GATHER_TABLE_STATS分析表

    表分析,简单的说,就是收集表和索引的信息,CBO根据这些信息决定SQL最佳的执行路径.通过对表的分析,可以产生一些统计信息,通过这些信息oracle的优化程序可以进行优化. 语法: DBMS_STAT ...