Python3 第一章 基础语法

第一个python程序

#!/usr/bin/python3
# encoding:utf-8
import time as t
    def __init__(self,str):
        self.name =  str
    def outContent(self):
        print(self.name)

if __name__ == "__main__":
    test = testClass('Hello Word!!!')
    test.outContent() #打印"Hello Word!!!

基础语法说明：

表示python3版本
    #!/usr/bin/python3
输出中文：
	# encoding:utf-8
标识符（变量、函数、类、模块以及其他对象的名称）：
	1.第一个必须为字母或下划线 _ 
	2.其他可以为字母/数字/下划线_
	3.不能包含空格、@、% 以及 $ 等特殊字符
	4.不能能和 Python 中的保留字相同
	5.大小写敏感
输入
    input() 
打印
    print()
导入time的所有成员变量（包括变量、函数、类等）
    import time as t (import 模块 as 别名)
    from 模块 import 类 as 别名
注释
	单行 #
	多行 '''   '''
行与缩进
    def outContent(self):
        print(self.name)# python需注意缩进，缩进不一致，会导致运行错误
数据类型
	python中数字有四种类型：整数（int）、布尔型（bool）、浮点数（float）和复数（complex）
定义类 
    class 类名
定义函数
    def 函数名 
构造函数
     def __init__(self,str):
        self.name =  str
     1.实例化类即执行构造函数，并且可对构造函数传参
     2.构造函数可以定义类的局部变量，如self.name =  str
程序入口
    if __name__ == "__main__"
实例化类
    test = testClass('Hello Word!!!')
    'Hello Word!!!' 为构造函数传参值
根据实例化的类执行函数
    test.outContent() 

Python3 第二章 字符串(String)

1.引号使用

1.单引号和双引号使用完全相同，表示字符串
2.使用三引号可以指定一个多行字符串，并且无需转义符即可显示按行显示
例如：print("""第一行
            第二行""")
#打印结果：第一行
           第二行

2.转义符

1.常用转义符\'（单引号） \\（反斜杠符号） \n（换行） \r（回车） \(在行尾时 续行符) \000（空）
    例如换行：print("第一行\n第二行")，
    #打印结果：第一行
              第二行
2.引号前加字母r，表示不转义
    例如：print(r"第一行\n第二行")
    #打印结果：第一行\n第二行

3.字符串常用函数方法使用

3.1.+：连接，*：重复

例如：print("第一行"+"第二行")
#打印结果：第一行第二行
例如：print("第一行"*3)
#打印结果：第一行第一行第一行

3.2.字符串截取

字符串下标从左0开始，从右-1开始
str='Runoob'
print(str[0:-1]) 
#打印结果：Runoo（输出第一个到倒数第二个的所有字符） 
print(str[2]) 
#打印结果：n
print(str[2:5])
#打印结果：noo

3.3.字符串运算

str='abc'
print('a' in str)
#打印结果：True（表示包含a值）
print('a' not in str)
#打印结果：False

3.4.替换

str='abc'
print(str.replace('a', 'f'))
#打印结果：fbc（a替换成f）

3.5. 长度

str='abc'
print(len(str))
#打印结果：3（长度为3）

3.6.下标位置查找

str='abc'
print(str.find('c'))
#打印结果：2 （查询c在哪个下标位置）
print(str.find('c',1,len(str)))
#打印结果：2 （从下标1开始到整个字符长度，查询c在哪个下标位置）
print(str.find('e'))
#打印结果：-1 （如果不存在e则返回-1）
print(str.index('c'))
#打印结果：2 （查询c在哪个下标位置）    	
print(str.index('c',1,len(str)))
 #打印结果：2 （从下标1开始到整个字符长度，查询c在哪个下标位置）  
print(str.index('e'))
#打印结果：没有e，则报异常

3.7.分割split

txt = "aa#bb#cc#dd"
x = txt.split("#", 1) 
print(str(x))
#打印结果：['aa', 'bb#cc#dd']（按#符号分割1次，返回是一个list值）
y=txt.split("#", txt.count('#')) 
y=txt.split("#") 
print(str(y))
#打印结果：['aa', 'bb', 'cc', 'dd']（按#符号分割，返回是一个list值）

3.8.去除空格

str=' abc '
print(str.strip())
#打印结果：abc（去除两头空格）

3.9.统计

str='abca'
print(str.count('a'))
#打印结果：2 （统计a个数）
print(str.count('a',2,len(str)))
#打印结果：1 （从str下标2到最后一个长度统计a的个数）

3.10.字母转换

str='Abc'
print(str.lower())
#打印结果：abc （转换小写）
print(str.upper())
#打印结果：ABC （转换大写）
print(str.swapcase())
#打印结果：aBC （大写转换成小写，小写转换成大写）
print(max(str))
#打印结果：c （最大字母）
str='abc'
print(str.title())
print(str.capitalize())
#打印结果：Abc （第一个字母大写其它小写）
print(str.startswith('a',0,2))
#打印结果：True （是否是a开头）

3.11.判断字母数字

str='a12'
print(str.isalnum())
#打印结果：True （字符串由数字+字母组成返回true，如果有除数字或字母以外的符号返回flase）
str='abb'
print(str.isalpha())
#打印结果：True （全部是字母则返回 True, 否则返回 False）
str='111'
print(str.isdigit())
print(str.isnumeric())
#打印结果：False （全部是数字则返回 True, 否则返回 False）
str='a123bc'
print(str.islower())#
#打印结果：True（至少一个小写字母+没有大写则返回 True, 否则返回 False）
str='A123'
print(str.isupper())
#打印结果：True（至少一个大写字母+没有小写则返回 True, 否则返回 False）

4.字符串格式化

%s 格式化字符串 %d 格式化整数
print("我叫 %s今年 %d岁" % ('小明',5))#我叫 小明今年 5 岁
#打印结果：我叫 小明今年 5岁

Python3 第三章 基本数据类型

1.单个变量赋值

counter = 100 # 整型变量 
miles = 1000.0 # 浮点型变量 
name = "runoob" # 字符串

2.多个变量赋值

a = b = c = 1
a, b, c = 1, 2,"runoob"

3.标准数据类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List[列表]、Dictionary{字典}、Set（集合）

4.数字

4.1.获取类型

print(type(1)) 
#打印结果：<class 'int'> （int为数字类型）

4.2.判断对象类型

print(isinstance(1, int)) 
#打印结果：True （表示1是int类型）
print(isinstance(1, float))
#打印结果：False（表示1不是float类型）
isinstance('put',str) 
#打印结果：True(表示'put'不是字符串类型)
isinstance({'key':'vaule'},dict) 
#打印结果：True(表示{'key':'vaule'}不是字典类型)

4.3.数字运算

2 / 4 # 除法，得到一个浮点数 0.5 
2 // 4 # 除法，得到一个整数 0 
17 % 3 # 取余 2 
2 ** 5 # 乘方 32

4.4.删除变量

var=1 del var

Python3 第四章 列表[,]

1.获取列表值

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[1]) 
#打印结果：786 （下标从0开始）
print (list[-1]) 
#打印结果：70.2 （右侧下标从-1开始）
print (list[2:]) 
#打印结果：[2.23, 'runoob', 70.2]（输出从第三个元素开始的所有元素）

2.列表运算

包含
    print(123 in ['a',123])
    #打印结果：True （列表包含值123，注意类型也需要一致，例如列表值123为'123'，那么则返回False，因为一个是数字型一个是字符型）
    print(1 not in ['a',123])
    #打印结果：True （列表不包含值1）
相加
	print (['a','b'] + ['c','d'] ) 
	#打印结果：['a', 'b', 'c', 'd']

3.列表赋值

列表名[下标]=赋值
listN = ['a','f','c']
listN[1] = 'b'
print(listN)
#打印结果：['a', 'b', 'c']

listN.append([6,7])
print(listN)
#打印结果：['a', 'f', 'c', [6, 7]]（追加）

intlist = ['a']
intlist.extend(['f','x'])
print(intlist)
#打印结果：['a', 'f', 'x']（通过添加指定列表的所有元素来扩充列表）

intlist = ['a']
intlist.insert(0, 'f')#按索引下标0的位置插入内容'f'
print(intlist) 
#打印结果：['f', 'a']

4.列表删除清空

inylist = ['a','b']
del inylist[0]  #删除
print(inylist)
#打印结果：['b']

stra = ['a','b']
stra.pop(1)
print(stra)
#打印结果：['a']#按索引位置删除

intlist = ['a','b','a'] 
intlist.remove('a')
print(intlist)
#打印结果： [b','a'] （移除列表中某个值的第一个匹配项）

intlist.clear()
print(intlist) 
#打印结果：[]（清空列表）

5.列表查询统计

intlist = [5,2,1] 
print(len(intlist))
#打印结果：3（长度）
print(max(intlist))
#打印结果：5（最大值）
print(min(intlist))
#打印结果：1 （最小值）
print(intlist.count(2))
#打印结果：1（元素出现的次数）
print(intlist.index(1))
#打印结果：2 （元素索引位置）
intlist.reverse()

6.列表复制

alist=['a','b']
intlist=alist.copy()
print(intlist) 
#打印结果：['a', 'b']（intlist复制alist）

7.列表排序

intlist = [5,1,2] 
intlist.sort()
print(intlist) 
#打印结果：[1, 2, 5]

8.列表反转

intlist = [5,2,1]
intlist.reverse()
print(intlist)
#打印结果：[1, 2, 5]

9.输出两次列表

tinylist = [123, 'runoob'] 
print (tinylist * 2) 
#打印结果：[123, 'runoob', 123, 'runoob']

10.列表遍历

list =['a',1,'b']
for l in list:
    print(l)
for i in (range(len(list))):
    print(list[i])
两种方式#打印结果：a
                  1
                  b

Python3 第五章 元组()

1.元组属性

不可赋值（虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表）
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号（元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：）

2.获取元组值

tuple = ( 'a', 1 , 2, 'b') 
print(tuple[1])
#打印结果：1 （下标从0开始）
print(tuple[2:])
#打印结果：(2, 'b') （从下标2开始一直到最后一个值）
print (tuple[1:3]) 
#打印结果：(1, 2) （从下标1到下标3的值）
print(tuple[-3:])
#打印结果：(1, 2, 'b')（右边下标从-1开始）

3.元组遍历

tup =('a','b')
for t in tup:
    print(t)
#打印结果：a
          b

4.删除元组

tup =('a','b')
del tup2 删除表记录，因为元组不能修改只能全部删除

5.元组运算

tup = (1,2)+(3,4)
print(tup)
#打印结果：(1, 2, 3, 4)

print(1 in tup)
#打印结果：True （表示元组tup包含数字1）

6.元组查询

tup =  (1, 2, 3, 4)
tup =  (1, 2, 3, 4)
print(max(tup))
##打印结果：4 （最大值）
print(min(tup))
##打印结果：1 （最小值）
print(len(tup))
##打印结果：4 （长度）
print(tup*2)
##打印结果：(1, 2, 3, 4, 1, 2, 3, 4) （重复两遍输出）

Python3 第六章 集合大括号 { } 或者 set()

1.集合定义

1.函数创建集合,创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
2.定义集合：
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'} 
或者
student =set(['Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'])
print(student)	
#打印结果： {'Tom', 'Mary', 'Jack', 'Jim', 'Rose'} （集合会去重（集合的值都是唯一的））

3.定义集合，值为字符
student =set('abc')
print(student)
#打印结果：{'b', 'a', 'c'}

2.集合运算

包含
	print('a' in student)
	#打印结果：True （集合包含'a'值）
相减
	stra=set('abc')
	strb=set('ad')
    print(stra-strb)
    #打印结果：{'c', 'b'} （集合stra中包含而集合strb中不包含的元素）
或
	stra=set('abc')
	strb=set('ad')	    
    print(stra | strb)
    #打印结果：{'b', 'a', 'd', 'c'}（集合stra或strb中包含的所有元素）
且
	stra=set('abc')
	strb=set('ad')		    
	print(stra & strb)
	#打印结果：{'a'} （集合stra并strb中都包含了的元素）
异
	print(stra ^ strb)
	#打印结果：{'d', 'c', 'b'} （不同时包含于stra或strb的元素）

3.集合添删改查

新增
	stra={'a','b','c'}
	stra.add('d')
	print(stra)#新增 
	#打印结果：{'d', 'c', 'a', 'b'}（没有则添加，有就保持原有的）
删除
    stra={'a','b','c','d'}
	stra.remove('d')#删除,无则报异常
	stra.discard('d')#删除,如无异常不报错
	print(stra)
	#打印结果：{'a', 'b', 'c'},
	stra.pop()#随机删除
	
    stra={'a','b','c','d'}
    stra.clear()
    print(stra)
    #打印结果：set() （清空）
更新
    stra={'a','b','c','d'}
    strb={'a','k'}
    stra.update(strb)
    print(stra)
    #打印结果：{'c', 'd', 'k', 'a', 'b'}（通过添加另一个集合中的项目来更新当前集合,如果两个集合中都存在一个值，则更新后的集合中将仅出现一次该值）
查询
    stra={'a','b','c','d'}
    print(len(stra))
    #打印结果：4 （长度）

4.集合复制

stra={'a','b'}
strb = stra.copy()
print(strb)
#打印结果：{'b', 'a'}

5.集合合并

stra={'a','b'}
strb ={'c'}
print(stra.union(strb))
#打印结果：{'a', 'b', 'c'}

Python3 第七章 Dictionary{字典}

1.字典属性

字典是一个无序的 键(key) :值(value)的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

2.字典添加获取

#定义空字典
zd = {}
#字典赋值key = 'one' vaule='aa'
zd['one'] = "aa" 
#字典赋值key = 2 vaule='bb'
zd[2] = "bb" 
print(zd)
#打印结果：{'one': 'aa', 2: 'bb'}
print (zd['one']) 
#打印结果：aa（ 根据key值 'one'获取value值）
print (zd.keys()) 
#打印结果：dict_keys(['one', 2])（获取字典所有key值）
print (zd.values()) 
#打印结果：dict_values(['aa', 'bb'])（获取字典所有vaule值）

#字典定义（另一种方式）
zd = dict(a=1,b=2)
print(zd)
#打印结果：{'a': 1, 'b': 2}

3.字典删改查

删除
    zd={'key1':1,'key2':2}
    del zd['key1']
    print(zd)
    #打印结果：{'key2': 2}（根据key值删除）
    print (zd.clear())
    #打印结果：None （全部清空）
    del zd
    print(zd)
    #打印结果：NameError: name 'zd' is not defined （删除对象）
    #随机删除
    zd.popitem()
修改
    zd={'key1':1,'key2':2}
    zd['key1']='one'
    print(zd)
    #打印结果：{'key1': 'one', 'key2': 2}（key1，vaule值修改成'one'）
    
    kv1={'key1':'字典1','key2':'字典2'}
    kv2={'key1':'字典1','key3':'字典3'}
    #把字典kv2更新到kv1
    kv1.update(kv2)
    print(kv1)
    打印结果：{'key1': '字典1', 'key2': '字典2', 'key3': '字典3'}
查询
    zd={'key1':1,'key2':2}
    print (zd.__len__())
    print (len(zd))
    #打印结果：2 （长度）

4.字典遍历

#分别遍历key值与value值
kv={'key1':'字典1','key2':'字典2'}
for k,v in kv.items():
    print(k,v)
#打印结果：key1 字典1
           key2 字典2

#遍历key值
for k in kv.keys():
    print(k)
#打印结果：key1
           key2

#遍历vaule值
for v in kv.values():
print(v)
#打印结果：字典1
           字典2

#以列表返回可遍历的(键, 值) 元组数组
for i in kv.items():
    print(i)
#打印结果
    ('key1', '字典1')
    ('key2', '字典2')

5.字典运算

kv1={'key1':'字典1','key2':'字典2'}
print('key1' in kv1)
#打印结果：True （如果键在字典dict里返回true，否则返回false）

Python3 第八章 Python数据类型转换及运算

1.字典转字符串

import json
zd={'key1':1,'key2':2}
#第一种方式
zf = str(zd)
#低二种方式
zf = json.dumps(zd,ensure_ascii=False)
#打印结果：<class 'str'>（类型字符串）

2.字符串转字典

import json
import ast
zf='{"key1":1,"key2":2}'
#方式一  缺陷： 数组或对象之中的字符串必须使用双引号，不能使用单引号 (
#zd = json.loads(zf)
#方式二 推荐
zd = ast.literal_eval(zf)
print(type(zd))
#打印结果：<class 'dict'>（类型字典）

3.列表转元组

#列表
seq=[4,5,7]
l = tuple(seq)
print(type(l))
#打印结果：<class 'tuple'>

4.元组转列表

seq=(4,5,7)
l = list(seq)
print(type(l))
#打印结果：<class 'list'>

5.列表转集合

#列表
seq=[4,4,5,7]
l = set(seq)
print(type(l))
#打印结果：<class 'set'>

6.集合转列表

#集合
seq={4,4,5,7}
l = list(seq)
print(type(l))
#打印结果：<class 'list'>

7.列表转字典

#必须是一个序列 (key,value)才能转换
zd = dict([('a', 1), ('b', 2)])
print(zd)
#打印结果：{'a': 1, 'b': 2}

8.字符转数字、浮点数

s = '1'
#将x转换成数字型
i = int(s) 
print(type(i))
#打印结果：<class 'int'>

s = '1'
#将x转换成数字型
i = float(s) 
print(type(i))
#打印结果：<class 'float'>

9.数字转字符

i = 112
#将x转换成数字型
s = str(i) 
print(type(s))
#打印结果：<class 'str'>

10.运算符

算术运算符  + - * / %（取模） **(次方) //（取整）
比较（关系）运算符 == != > < >= <=
赋值运算符 = += -= *= /= %= **= //=
位运算符 &(与) |（或） ^（异1^1=0 1^0=1 0^0=0） ~反（1为0 1为1） <<(左移) >>（右移）
成员运算符
	in 
	not in
身份运算符
	is 是判断两个标识符是不是引用自一个对象（is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等）
	is not 是判断两个标识符是不是引用自不同对象
逻辑运算符 and or not
运算符优先级
**  ~ + -  * / % //  + -  >> << & ^ | <= < > >= <> == != = %= /= //= -= += *= **= is is not in not in  and or not

11.数学函数

import math 
#绝对值
print(abs(10))#打印结果：10
print (math.fabs(-10)) #打印结果：10.0
#数字的上入整数
print (math.ceil(4.01)) #打印结果：5
print (math.ceil(5.1))#打印结果：6
#四舍五入
print (round(5.2))#打印结果：5
print (round(5.5))#打印结果：6
#数字的下舍整数
print (math.floor(4.9))#打印结果： 4
#最大值
print (max(1, 2,3)) #打印结果：3
#最小值
print (min(1, 2,3)) #打印结果：1
#2的3字方
print (pow(2, 3)) #打印结果：8

12.随机数函数

import random
#0-9随机取一个整数
random.choice(range(10)) 

#randrange(开始,结束,基数缺省值)，从1-9取一个整数值，为1
random.randrange(1,10) 

#随机生成下一个实数，它在[x,y]范围内，如打印 4.7121876537805765
print(random.uniform(1,10))

#随机生成下一个实数，它在[0,1)范围内
print(random.random())#如打印0.3502778481985014

#将序列的所有元素随机排序
lst=[1,2,3,4,5,6]
random.shuffle(lst)
print(lst) #如随机打印：[4, 5, 6, 3, 2, 1]

13.类型比较函数

a = [1,2]
print(isinstance(a, list))
#打印结果：True

#字符类型比较
a = 'ssss'
print(isinstance(a, str))
#打印结果：True

#字典类型比较
a = {'key':'vaule'}
print(isinstance(a, dict))
#打印结果：True

#集合类型比较
a = set()
print(isinstance(a, set))
#打印结果：True

Python3 第九章 条件循环

1.条件控制（if）

比较运算符：< <= > >= == != in not in
a=0
b=1
if a==b: 
	print('打印a=b') 
elif a!=b: 
	print('打印a!=b')
else: 
	print('打印else')
#打印结果：a!=b

2.循环

2.1 循环语句（while for）

a=0
while a<3:
	print(a,end=',')
	a+=1
else:
	print('打印等于3')
#打印结果：0,1,2,打印等于3

2.2 break语句

l = [1,2,3]
for a in l:
    print(a,end=',')
    #直接退出循环
    break
else:
    print('打印完毕')
#打印结果：1,

2.3 continue语句

for a in [1,2,3]:
	if a==2:
	    #符合条件退出一次循环
		continue 
	print(a,end=',')
else:
	print('打印完毕')
#打印结果：1,3,打印完毕

2.4 range语句

for a in range(5):
	print(a,end=',')#打印结果：0,1,2,3,4,
for b in range(2,5):
	print(b,end=',')#打印结果：2,3,4,
for c in range(1,9,3):
	print(c,end=',')#打印结果：1,4,7,

3.5 pass语句

for letter in 'abc': 
    if letter == 'a': 
        pass
    else:
        print ('当前字母 :', letter)
print ("Good bye!")
#打印结果：当前字母 : b
           当前字母 : c
           Good bye!

Python3 第十章 迭代器,生成器

1.迭代器

1.访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
2.它与列表的区别在于，构建迭代器的时候，不像列表把所有元素一次性加载到内存，而是以一种延迟计算（lazy evaluation）方式返回元素，这正是它的优点。比如列表含有中一千万个整数，需要占超过400M的内存，而迭代器只需要几十个字节的空间。因为它并没有把所有元素装载到内存中，而是等到调用 next 方法时候才返回该元素（按需调用 call by need 的方式，本质上 for 循环就是不断地调用迭代器的next方法）。
3.迭代器有两个基本的方法：iter() 和next()字符串，列表或元组对象都可用于创建迭代器;

1.1 iter()方法

Strlist=['a','b','c']
it=iter(Strlist)
for x in it:
	print(x,end=" ")
#打印结果：a b c 

1.2 next() 方法

import sys
list=[1,2,3,4] 
it = iter(list) 
# 创建迭代器对象 
while True:
	try:
		print (next(it),end="") #打印1234
	except StopIteration: 
		sys.exit()

1.3 创建一个迭代器

class MyNumbers: 
	def __iter__(self): 
		self.a = 1 
		return self 
	def __next__(self): 
		x = self.a 
		self.a += 1 
		return x 
myclass = MyNumbers() 
myiter = iter(myclass) 
print(next(myiter)) 
print(next(myiter)) 
print(next(myiter)) 
print(next(myiter)) 
print(next(myiter))
#打印结果：
1
2
3
4
5

1.4 StopIteration 异常

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
class MyNumbers: 
    def __iter__(self): 
        self.a = 1 
        return self 
    def __next__(self): 
        if self.a <= 5: 
                x = self.a 
                self.a += 1 
                return x 
        else: 
            raise StopIteration #退出无限循环
if __name__=='__main__':
    myclass = MyNumbers() 
    myiter = iter(myclass) 
    for x in myiter:
        print(x)
#打印结果
1
2
3
4
5

2.生成器

生成器 在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值,并在下一次执行 next() 方法时从当前位置继续运行。调用一个生成器函数，返回的是一个迭代器对象。以下实例使用 yield 实现斐波那契数列：
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
	a, b, counter = 0, 1, 0
	while True:
		if (counter > n): 
			return
		yield a
		a, b = b, a + b
		counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
	try:
		print (next(f), end=" ")
	except StopIteration:
		sys.exit()
#打印结果：0 1 1 2 3 5 8 13 21 34 55 

Python3 第十一章 函数

1.定义函数

def 函数名（参数列表）:
	函数体
	
#实例一
def print_welcome(name): 
    print("Welcome:", name)     
print_welcome("Runoob") 
#打印结果：Welcome Runoob
#实例二
def area(width, height): 
    return width * height 
w = 4 
h = 5 
print("width =", w, " height =", h, " area =", area(w, h))
#打印结果：width = 4  height = 5  area = 20

2.传不可变对象实例

#!/usr/bin/python3
def ChangeInt( a ):
	a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2

3.传可变对象实例

#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
	#"修改传入的列表"
	mylist.append([1,2,3,4])
	print ("函数内取值: ", mylist)
	return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
#打印结果:
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

4.必传参数

#!/usr/bin/python3
def printme(str):
    #"打印任何传入的字符串"
    print (str)
    return
#调用printme函数
printme()#未传参数，报异常
#打印结果：TypeError: printme() missing 1 required positional argument: 'str'

4.默认参数

#!/usr/bin/python3
# encoding:utf-8
#默认age = 35
def printinfo( name, age = 35 ):
    #"打印任何传入的字符串"
    print ("名字: ", name)
    print ("年龄: ", age)
    return
printinfo( name="runoob" )
#打印结果：名字:  runoob
        年龄:  35

5.关键字参数

#!/usr/bin/python3
def printme(str):
	#"打印任何传入的字符串"
	print (str)
	return
#调用printme函数
printme(str = "菜鸟教程")
#打印结果：abc

6.不定长参数（*元组，**字典）

#不定长参数加一个*表示传入元组，两个新表示传入字典
#!/usr/bin/python3
# encoding:utf-8
#加了一个星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
def printinfo( arg1, *vartuple):
    #打印任何传入的参数
    print (arg1)
    print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )#元组
#打印结果：70
    (60, 50)

#!/usr/bin/python3
# encoding:utf-8
#加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vardict ):#
    #打印任何传入的参数
    print (arg1)
    print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)#列表
#打印结果 1
      {'a': 2, 'b': 3}

7.匿名函数

#所谓匿名，即不再使用 def 语句这样标准的形式定义一个函数
#!/usr/bin/python3
# encoding:utf-8
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
#打印结果：相加后的值为 :  30
           相加后的值为 :  40

8.变量作用域

g_count = 0  # 全局作用域
def outer():
	o_count = 1  # 闭包函数外的函数中
	def inner():
		i_count = 2  # 局部作用域

9.关键字global

#关键字global函数内定义全局变量
def hsbl():
    global s 
    s ='全局变量'
hsbl()#必须执行该函数全局变量才生效
print(s)
#打印结果：全局变量

10.关键字nonlocal

1.(如果要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了)
2.nonlocal语句允许在内存中保存可变状态的副本，并且解决了在类无法保证的情况下简单的状态保存。
3.当执行一条nonlocal语句时，nonlocal名称必须已经在一个嵌套的def作用域中赋值过,否则将会得到一个错误——不能通过在嵌套的作用域给它们一个新值来创建它们

#!/usr/bin/python3
# encoding:utf-8
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
#打印结果：100
           100

Python3 第十二章 模块

1.main运行

#!/usr/bin/python3
if __name__ == '__main__':
	print('程序自身在运行')
else:
	print('我来自另一模块')
#程序自身在运行

2.内置的函数 dir()

可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
#!/usr/bin/python3
import sys
print(dir(sys))
#如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

Python3 第十三章 输入输出

1.输出

#!/usr/bin/python3
# encoding:utf-8
s='hello word!\n'
#rjust()方法, 它可以将字符串靠右, 并在左边填充空格
#ljust() 靠左 和 center() 居中
print(str(s).rjust(4))
#打印结果：hello word!

# repr() 函数可以转义字符串中的特殊字符；repr() 的参数可以是 Python 的任何对象                 
print(repr(s))
#打印结果：'hello word!\n'
#格式化format
print('我是{name}，今年{age}岁'.format(name='小明',age=9))
#打印结果：我是小明，今年9岁
#它会在数字的左边填充 0 
print('12'.zfill(5))
#打印结果：00012

2.读取键盘输入

#!/usr/bin/python3
# encoding:utf-8
#请输入：123
str=input('请输入：')
print('打印结果：',str)
#打印结果： 123

3.写文件

#写实例
#!/usr/bin/python3
# encoding:utf-8
#open(filename, mode) 
#w：写入，文件不存在新增，如果存在同名文件则将被删除 w+ 读 写
#a：追加，文件不存在新增 a+:读写追加
#打开文件，写入模式
f=open('D:/p.txt','w')#如果写人非字符串内容，例如列表，元组，需先转换成str()
#写人内容
f.write('Python是一个很好的语言\n值得学习！')
#关闭文件
f.close

#结果：D盘新建了一个文件p.txt内容如下
Python是一个很好的语言
值得学习！

4.读文件

#读取部分
#!/usr/bin/python3
# coding=UTF-8
#打开文件，读取模式
##mode r：只读默认 r+：读写指针在开头 
f=open('D:/p.txt','r')
#5表示读取的长度
str = f.read(5)
print(str)
f.close
#打印结果：Pytho

#读取所有
#!/usr/bin/python3
# coding=UTF-8
f=open('D:/p.txt','r')
str1 = f.read()
print(str1)
f.close
#打印结果：Python是一个很好的语言
#          值得学习！


#读取所有并返回list内容
#!/usr/bin/python3
# coding=UTF-8
f=open('D:/p.txt','r')
str2 = f.readlines()
print(str2)
f.close
#打印结果：['Python是一个很好的语言\n', '值得学习！']

#遍历读取
#!/usr/bin/python3
# coding=UTF-8
f=open('D:/p.txt','r')
#遍历
for line in f:
	print(line,end='')
f.close
#打印结果
#Python是一个很好的语言
#值得学习！

#定位读
#!/usr/bin/python3
# coding=UTF-8
#打开文件，写入模式
f=open('D:/p.txt','r')#在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位
wz=f.seek(6,0)#(第几个位置，0开头，1当前，2结尾)
print('当前位置'+str(wz))#打印第几个位置
str = f.read()
print('seek(6,0)定位读取的内容：'+str)
#关闭文件
f.close

'''
内容：
Python是一个很好的语言
值得学习！
打印结果：
当前位置6
seek(6,0)定位读取的内容：是一个很好的语言
值得学习！
'''

Python3 第十四章 异常

1.除零异常实例

#!/usr/bin/python3
# coding=UTF-8
def this_fails():
        x = 1/0
try:
    this_fails()
except ZeroDivisionError as err:
    print('错误:', err)
#打印结果：错误: division by zero

2.不带异常类型

try:
    fh = open("2.txt", "r")
    print(fh.read())
except:
    print("不带异常类型")
else:
    print("没有异常执行这里")
#打印结果：不带异常类型

3.异常else用法

#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
    fh = open("1.txt", "w")
    fh.write("写入")
except IOError:
    print("文件不存在!!!")
else:
    print("文件写入成功，关闭文件")
    fh.close()
#打印结果：文件写入成功，关闭文件

#异常finally用法
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
    fh = open("2.txt", "r")
    print(fh.read())
except IOError:
    print("文件不存在!!!")
finally:
    print("此项内容必定执行")
#打印结果：文件不存在!!! 
#此项内容必定执行

4.抛出异常

#!/usr/bin/python
# -*- coding: UTF-8 -*-
raise Exception('抛出异常！！！')
'''
打印结果：
Traceback (most recent call last):
  File "D:\gogncheng\apiAutoMate\common\terst.py", line 3, in <module>
    raise Exception('抛出异常！！！')
Exception: 抛出异常！！！
'''

5.抛出异常不处理

#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
    raise NameError('抛出异常')
except NameError:
    print('抛出异常不处理!')
    raise
'''
抛出异常不处理!
Traceback (most recent call last):
  File "D:\gogncheng\apiAutoMate\common\terst.py", line 5, in <module>
    raise NameError('抛出异常')
NameError: 抛出异常
'''

6.自定义异常

#!/usr/bin/python
# -*- coding: UTF-8 -*-
class MyError(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)
   
try:
    raise MyError('err')
except MyError as e:
    print('自定义异常值:', e.value)
#打印结果：自定义异常值: err

Python3 第十五章 liunx下运行

linux执行
	Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样
	#! /usr/bin/env python3
	$ chmod +x hello.py
	./hello.py   #Hello, Python!