python初识

一、集合（set）

　　1.集合的定义

　　　　set 是一个无序的元素集合，支持并、交、差及对称差等数学运算， 但由于 set 不记录元素位置，

　　因此不支持索引、分片等类序列的操作。

　　2.集合的创建

　　　　大括号或 set() 函数可以用来创建集合。 注意:想要创建空集合,你必须使用set() 而不是 {} 。

　　　{}用于创建空字典　　　

　　　　

list = [1,3,2,4,2,5,7]
list = set(list) #将列表转成集合，集合用{}表示
print(list,type(list))#输出结果为：{1, 2, 3, 4, 5, 7} <class 'set'>
list2 = set([3,22,5,66,8,10])
print(list2,type(list2))#输出结果为：{66, 3, 5, 8, 10, 22} <class 'set'>

　　3.集合的添加和删除　

　　　　

list5 = {1,22,3}
list5.add(33) #添加
print(list5)#输出：{1,3,33,22}
list5.update([0,4,44]) #添加多项
print(list5)#输出：{0, 1, 33, 3, 4, 44, 22}

list5.remove(44) #移除一项
print(list5)#输出：{0, 1, 33, 3, 4, 22}
print(list5.pop())#随机删除
print(list5.discard(99))#删除，不存在时返回None,输出：None

　　4.集合的长度

　　　　

list = {0, 1, 33, 3, 4, 22}
print(len(list))#集合长度，#输出：6

　　5.集合成员的判断

　　　　

list = {0, 1, 33, 3, 4, 22}
print(99 in list) #判断其是否为集合成员，输出：False
print(99 not in list) #判断其是否非集合成员，输出：True

　　6.集合间的关系

　　　　集合间的关系包括交、差、并集，子集，对称差集，空集。

　　　　

list = set( [1,3,2,4,2,5,7])
list2 = set([3,22,5,66,8,10])

#交集
print(list.intersection(list2))#intersection意为交集，结果为{3, 5}
print(list & list2)#结果为{3, 5}

#并集
print(list.union(list2))#union意为联合，结果为{1, 2, 3, 4, 5, 66, 7, 8, 10, 22}
print(list | list2) #结果同上

#差集（一方独有的，另一方无的集合）
print(list.difference(list2))#输出：{1, 2, 4, 7}
print(list - list2)#输出：{1, 2, 4, 7}
print(list2.difference(list))#输出：{8, 66, 10, 22}

#子集  issubset用于判断一个集合的所有元素是否都包含于另一个集合
list3 = set([1,3,5])
print(list.issubset(list3))#输出：False,即list不是list3的子集
print(list3.issubset(list))#输出：True,即list3是list的子集
print(list<= list2)#判断list是否为list2的子集

#对称差集(等同于两差集之和)
print(list.symmetric_difference(list2))#输出：{1, 66, 2, 7, 22, 4, 8, 10}
print(list ^ list2) #结果同上

#空集，若两个列表无交集，返回True,有交集返回False
list4 = set([0,11,33])
print(list3.isdisjoint(list4))#输出：True,即两个列表无交集
print(list.isdisjoint(list2))#输出：False,两个列表有交集

二、文件常用操作

　　1.　文件的创建删除和重命名

　　　　

import os
os.mknod("test.txt")             #创建空文件
fp = open("test.txt",w)          #直接打开一个文件，如果文件不存在则创建文件
os.remove()                         #  函数用来删除一个文件  
os.rename（old， new）         #重命名
os.path.getsize（filename）        #获取文件大小

　　2.目录的创建删除和重命名

　　　　

import os,shutil
os.mkdir("file")                   #创建目录
os.makedirs（r“c：python	est”）#创建多级目录
os.rename("oldname","newname")   #重命名文件（目录）文件或目录都是使用这条命令   
os.rmdir("dir")                             #只能删除空目录
shutil.rmtree("dir")                        #空目录、有内容的目录都可以删 
os.chdir("path")                            #转换目录，换路径
shutil.copytree("olddir","newdir")  #olddir和newdir都只能是目录，且newdir必须不存在
shutil.move("oldpos","newpos")       #移动文件（目录）

　　3.文件的读写操作（较繁多，以举例子的方式说明）

　　　　

f1 = open('faded','r',encoding='utf-8') #文件句柄（文件的内存对象，包括文件的起始位置，文件名，字符集等），faded为已创建的文件
print(f1.read()) #只读
for i in range(10): #打印前10行
    print(f1.readline().strip()) #每次打印一行，去除空格和换行 

f2= open('faded2','w',encoding='utf-8') #只写
f2.write('You were the shadow to my light
你是我生命之光中的一道暗影
Did you feel us
你能理解我们吗')

f2= open('faded2','a',encoding='utf-8')#'a'即 append,追加
f2.write('
Another star
另一颗行星
You fade away
你逐渐消失')
#f1.close() #关闭
f2.close()

print(f1.tell())#表示开头位置，结果为：0
print(f1.readline()) #打印一行
print(f1.tell()) #打印此时光标的位置，结果为：31
print(f1.readline()) #打印一行,结果为：You were the shadow to my light
print(f1.tell())#打印此时光标的位置，结果为：64
print(f1.seek(31))#打印光标返回的位置，结果为：31
print(f1.readline())#结果为：You were the shadow to my light

print(f1.encoding)#打印编码格式，结果为：utf-8

#print(f2.flush())#实时刷新，无此方法时缓存满了一次刷新到硬盘中


# f2= open('faded2','a',encoding='utf-8')
# print(f2.truncate(20))#truncate意为把...截短，此处指从头开始截取20个字符
'''
f2= open('faded2','r+',encoding='utf-8')#文件句柄，读写(可读可写)
print(f2.readline())
print(f2.readline())
f2.write('
qwertyuiop
')
f2.write('asdfghjkl')
print(f2.readline())
'''
'''
f3= open('faded3','w+',encoding='utf-8')#文件句柄，写读
f3.write('Another dream
')
f3.write('另外的梦想
')
print(f3.tell())
print(f3.seek(0))
print(f3.readline())
'''
f2= open('faded2','a+',encoding='utf-8')#文件句柄，追加写读
f2.write('
Where are you now
')
print(f2.tell())
print(f2.seek(0))
print(f2.readline())
f2.write('Another dream
')
print(f2.tell())
'''

f2= open('faded2','rb')#文件句柄，读，二进制文件（文件传输）
print(f2.readline()) #输出：b'Another dream
'
print(f2.readline()) #输出：b'xe5x8fxa6xe5xa4x96xe7x9ax84xe6xa2xa6xe6x83xb3
'
'''
'''
f2= open('faded2','wb')#文件句柄，写，二进制文件（文件传输）
f2.write('Hello python
'.encode())#默认utf -8
f2.write('Hello python
'.encode())#默认utf -8
f2.close()
'''
   

　　4.关于文件打开模式的几点参照

　　　　

w：以写方式打开，
a：以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+：以读写模式打开
w+：以读写模式打开 (参见 w )
a+：以读写模式打开 (参见 a )
rb：以二进制读模式打开
wb：以二进制写模式打开 (参见 w )
ab：以二进制追加模式打开 (参见 a )
rb+：以二进制读写模式打开 (参见 r+ )
wb+：以二进制读写模式打开 (参见 w+ )
ab+：以二进制读写模式打开 (参见 a+ )

　　5.关于flush(刷新)的一个例子

　　　　

import  sys,time
for i in range(60):
    sys.stdout.write('*')
    sys.stdout.flush()
    time.sleep(0.2)

三、字符编码格式的转换　　

　　　　

#-*- coding:utf-8 -*- 文件编码
str = '我们不忘初心'
print(str,type(str))#输出：我们不忘初心 <class 'str'>
str_utf_gbk = str.encode('gbk')#encode表编码，unicode转utf-8或gbk要用encode,而utf-8和gbk转unicode要用decode
print(str_utf_gbk,type(str_utf_gbk))#输出：b'xcexd2xc3xc7xb2xbbxcdxfcxb3xf5xd0xc4' <class 'bytes'>
print(str_utf_gbk .decode('gbk'))#输出：我们不忘初心(byte->string，decode意为解码)

str2 = '我们直面未来'
#utf-8无需向Unicode转码，直接用encode+最终编码格式即可转为gbk或utf-8
print(str2.encode('gbk'),type(str2.encode('gbk')))#输出：b'xcexd2xc3xc7xd6xb1xc3xe6xcexb4xc0xb4' <class 'bytes'>
print(str.encode('utf-8'),type(str.encode('utf-8')))#输出：b'xe6x88x91xe4xbbxacxe4xb8x8dxe5xbfx98xe5x88x9dxe5xbfx83' <class 'bytes'>

utf_gbk = str2.encode('gbk')#此处无decode方法,用encode('gbk')即可转为gbk编码
print(utf_gbk)#输出：b'xcexd2xc3xc7xd6xb1xc3xe6xcexb4xc0xb4'

byte_string = utf_gbk.decode('gbk')
print(byte_string ,type(byte_string))#输出:我们直面未来 <class 'str'>

gbk_utf = utf_gbk.decode('gbk').encode('utf-8')
print(gbk_utf,type(gbk_utf)) #输出:b'xe6x88x91xe4xbbxacxe7x9bxb4xe9x9dxa2xe6x9cxaaxe6x9dxa5'

四、函数的简单入门

　　1.函数的介绍　　

　　　　函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

　　　　函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

　　2.函数的定义

　　　　你可以定义一个由自己想要功能的函数，以下是简单的规则：

　　　　　　<1>函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

　　　　　　<2>任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

　　　　　　<3>函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。（虽非必需，但强烈建议写上少量说明文字）

　　　　　　<4>函数内容以冒号起始，并且缩进。

　　　　　　<5>return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

　　　　　　<6>用例子说明:

　　　　　　　　

import time
#f1 = open('notebook','r',encoding = 'utf-8')
#函数的好处：代码重用；保持一致性；可扩展性
def add():
    '''文本追加内容并添加日志时间'''
    time_formate = '%y-%m-%d %x' #时间的格式
    time_current = time.strftime(time_formate)#引用上述的时间格式
    with open('notebook.txt','a+',encoding='utf-8') as f:
        f.write('Time is %s go on
'%time_current)

def test1():
    '''日志一'''
    print('This is test1')
    add()

def test2():
    '''日志二'''
    print('This is test2')
    add()

def test3():
    '''日志三'''
    print('This is test3')
    add()

test1()
test2()
test3()

　　3.函数参数及调用　　　

　　　　

'''
#return 返回值
def test1():
    print('test 1')

def test2():
    print('test 2')
    return 0

def test3():
    print('test 3')
    return 1,'hello',['hello','world'],{'China':'big'}

t1 = test1()
t2 = test2()
t3 = test3()
print(t1,type(t1)) #运行结果：None<class 'NoneType'> 返回值为None
print(t2,type(t2)) #运行结果：0 <class 'int'> 返回值为 0
print(t3,type(t3)) #运行结果：(1, 'hello', ['hello', 'world'], {'China': 'big'}) <class 'tuple'> 返回值为 一个元组
'''
#关键字调用与标准调用
def test(x,y,z):
    print(x)
    print(y)
    print(z)

#test(y=1,x=1)#关键字调用，与形参（位置参数）顺序无关
#test(2,1)#标准调用与形参一一对应
#test(x=3,2,z=4,)  #报错，关键字调用不能在标准调用之前
test(2,z=4,y=3) #两者一起使用,输出结果：2 3 4

　　4.函数非固定传参

　　　　

#默认参数
def test4(x,y=1):  #y=1为默认参数，且必须在形参之后，即（x=1,y）报错
    print(x,y)
#test4(2)#输出结果：2 1
test4(3,4)#输出结果：3 4
#默认参数的特点：调用参数时，默认参数非必须传递
#用途：默认安装值；

#参数组（* 参数组名字）,接受N个位置参数,转换成元组的形式
def test1(x,*args):  #形参数目不固定时，用*args接受
    print(x)
    print(args)

test1(0,3,5,6,6) #输出：0   (3,5,6,6)
test1(*[1,2,4,5,5])# 传递列表,输出：1  (2,4,5,5)

#字典的传递（**kwargs），接受N个关键字参数，转换成字典的形式
def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['sex'])

test2(name='hyt',age=18,sex='girl') #输出：{'age': 18, 'sex': 'girl', 'name': 'hyt'}
test2(**{'name':'sc','age':'20','sex':'boy'})#输出同上

#默认函数，参数组，字典同时传递
def test3(name,age=19,*args,**kwargs):
    print(name) #输出一：hyt    输出二：sc
    print(age) #输出一：18      输出二：20
    print(args) #输出一:(('sex', 'girl'), {'game': 'yys'})  输出二：()
    print(kwargs)#输出一：{}    输出二：{'game': 'lol', 'sex': 'boy'}

test3('hyt',18,('sex','girl'),{'game':'yys'})#测试一,关键字参数必须在位置参数之后
test3('sc',20,sex='boy',game='lol') #测试二，关键字参数必须在位置参数之后

　　

　　5.函数局部变量和作用域　　　

　　　　<1>.在程序一开始定义的变量称为全局变量；在子程序中定义的变量称为局部变量。

　　　　<2>全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

      <3>当全局变量与局部变量重名时，在定义局部变量的子程序内，局部变量起作用，在其它地方全局变量起作用。
　　　<4>下面用例子说明：

　　　　　　

school = 'BeiDaQingNiao' #全局变量
age = 18 #全局变量
def change_age(age):
    #global school  #声明全局变量，已有此全局变量时则修改，没有则创建，但不建议使用！
    print('before_age:',age) #结果：before_age: 18
    school = 'oldBoy'
    age = 20  #局部变量，这个函数就是它的作用域
    print('after_age:',age) #结果：after_age: 20
    print('school_jubu:',school)

change_age(age)
print(age) #结果：18
print('school_quanju:',school)

#一般情况下，不能在修改函数里修改局部变量为全局变量，如数字，字符，字符串，但列表，字典，集合，类可以改
mes = ['sc','boy',20]
def change_mes(mes):
    mes[0] = 'hyt'
    mes[1] = 'girl'
    mes[2] = '18'
    print('change inside:',mes)  #输出结果：change inside: ['hyt', 'girl', '18']
change_mes(mes)
print('ouside:',mes)  #输出结果：ouside: ['hyt', 'girl', '18']

　　6.函数递归和高阶函数

　　　　<1>递归函数：在函数内部，可以调用其它函数，如果一个函数在内部调用自己本身，则称为递归函数。

　　　　<2>递归的三个主要特性：

　　　　 　--->1.必须有一个明确的结束条件

　　　　　 --->2.每次递归进入更深一层时，问题规模都应比上次递归有所减少

         --->3.递归的效率不高，递归层次过多会导致溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
　　　　　　 每当进如一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无线的，所以，
　　　　　　递归调用的次数过多，会导致栈溢出）

　　　　 <3>实例如下：　　　　　

　　　　　　

def recur(n):
    print('list:',n)
    if int(n/2) > 0:
        return recur(int(n/2)) #递归调用
    print('the_last:',n) #输出：1
recur(12)

　　　　

　　　　<4>高阶函数：变量可以指向函数，函数的参数能接受变量，那么一个函数就可以接收另一个函数作为参数，

　　　　　　　　这种函数就是高阶函数。　　　

　　　　　　

def add(x,y,f):
    return f(x)+f(y)
res = add(-4,-8,abs) #abs为参数的内置函数
print('the result:',res)#输出结果：the result: 12

　

　　以上有部分内容摘自菜鸟教程和脚本之家，详情请戳

　　　　菜鸟教程：http://www.runoob.com/python/python-functions.html

　　　　脚本之家：http://www.jb51.net/article/48001.htm