python基础（常用实践）
目录
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!
前事不忘，后事之师
