数据类型
算术运算符
逻辑运算符
以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 Fal |
字符串内建函数
字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Jython中。
这些方法实现了string模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。
| 方法 | 描述 |
|---|---|
| 把字符串的第一个字符大写 | |
| 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 | |
| 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | |
| 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace' | |
| 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' | |
| 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | |
| 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 | |
| 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 | |
| 格式化字符串 | |
| 跟find()方法一样，只不过如果str不在 string中会报一个异常. | |
| 如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False | |
| 如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False | |
| 如果 string 只包含十进制数字则返回 True 否则返回 False. | |
| 如果 string 只包含数字则返回 True 否则返回 False. | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False | |
| 如果 string 中只包含数字字符，则返回 True，否则返回 False | |
| 如果 string 中只包含空格，则返回 True，否则返回 False. | |
| 如果 string 是标题化的(见 title())则返回 True，否则返回 False | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | |
| 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 | |
| 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 | |
| 转换 string 中所有大写字符为小写. | |
| 截掉 string 左边的空格 | |
| maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 | |
| 返回字符串 str 中最大的字母。 | |
| 返回字符串 str 中最小的字母。 | |
| 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. | |
| 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. | |
| 类似于 find()函数，不过是从右边开始查找. | |
| 类似于 index()，不过是从右边开始. | |
| 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 | |
| 类似于 partition()函数,不过是从右边开始查找 | |
| 删除 string 字符串末尾的空格. | |
| 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串 | |
| 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | |
| 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. | |
| 在 string 上执行 lstrip()和 rstrip() | |
| 翻转 string 中的大小写 | |
| 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) | |
| 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 | |
| 转换 string 中的小写字母为大写 | |
| 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
常用函数
1 数学函数
1.1 abs()函数——获取绝对值
1.2 divmod()函数——获取商和余数的元组
1.3 sum()函数——求和
1.4 round()函数——保留n位小数，四舍五入
1.5 pow()函数——求指数运算
1.6 min()函数——求最小值
1.7 max()函数——求最大值
2 数据转换函数
2.1 hex()函数——转化为十六进制(0x)
2.2 oct()函数——转化为八进制(0o)
2.3 bin()函数——转化为二进制(0b)
2.4 int()函数——转化为int类型
2.5 float()函数——转化为浮点类型
2.6 str()函数——转化为str类型
2.7 bool()函数——转化为bool类型
2.8 ord()函数——获取ASCII或者Unicode
2.9 chr()函数——获取数组对应的字符
2.10 tuple()函数——转化为元组
2.11 list()函数——转化为列表类型
2.12 set()函数——转化为集合类型
2.13 complex()函数——转化为复数形式
3 对象创建函数
3.1 range()函数——创建列表
3.2 set()函数——创建无序集合
4 迭代器操作函数
4.1 all()函数——判断序列是否全为True
4.2 any()函数——判断序列是否全为False
4.3 iter()函数——生成迭代器
4.4 sorted()函数——排序
4.5 enumerate()函数——组合数据对象为带有数据和数据下标的索引序列
4.6 filter()函数——指定过滤条件进行筛选
4.7 map()函数——自定义函数实现元素映射操作
4.8 reversed()函数——逆序
5 对象操作函数
5.1 id()函数——获取对象内存地址
5.2 eval()函数——执行一个字符串表达式并返回结果
5.3 exec()函数——执行字符串或者文件中的语句
5.4 type()函数——获取对象类型
6 字符串函数变量作用域
"""
变量作用域
"""
g1 = 'one'
def func():
g1 = 'one piece'
global g2
g2 = 'two piece'
print("In func():", g1)
print("In func():", g2)
print("inside : id(g1) = %s" %(id(g1)))
print("inside : id(g2) = %s" %(id(g2)))
g2 = 'two'
func()
print("g1 = ", g1)
print("g2 = ", g2)
print("outside: id(g1) = %s" %(id(g1)))
print("outside: id(g2) = %s" %(id(g2)))
结果：
In func(): one piece
In func(): two piece
inside : id(g1) = 3143475102704
inside : id(g2) = 3143475102768
g1 = one
g2 = two piece
outside: id(g1) = 3143472021608
outside: id(g2) = 3143475102768
列表
二维列表
a = [
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"],
]
for m in range(3):
for n in range(4):
print(a[m][n],end="\t")
print() #打印完一行，换行练习
''' 有一个列表a[],里面有若干个整数未知。 我希望将里面的整数两两做差（ 即a[1]-
a[0],a[3]-a[2]....） ， 并将得数保存在另一个列表b[]中， 请问如何实现
'''
a = [10,20,30,40,50,60,70,80,90,100]
b = []
l = len(a)//2
for i in range(l):
b.append(a[i*2+1]-a[i*2])
print(b)元组
元组的创建
1. 通过()创建元组。小括号可以省略。
a = (10,20,30) 或者 a = 10,20,30
如果元组只有一个元素， 则必须后面加逗号。 这是因为解释器会把(1)解释为整数 1， (1,)解释为元组。
>>> a = (1)
>>> type(a)
<class 'int'>
>>> a = (1,) #或者 a = 1,
>>> type(a)
<class 'tuple'>
2. 通过 tuple()创建元组
tuple(可迭代的对象)
例如：
b = tuple() #创建一个空元组对象
b = tuple("abc")
b = tuple(range(3))
b = tuple([2,3,4])元组的访问
1.元组的元素访问和列表一样，只不过返回的仍然是元组对象。
>>> a = (20,10,30,9,8)
>>> a[1]
10
>>> a[1:3]
(10, 30)
>>> a[:4]
(20, 10, 30, 9)
2. 列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数 sorted(tupleObj)，并生成新的列表对象。
>>> a = (20,10,30,9,8)
>>> sorted(a)
[8, 9, 10, 20, 30]元组总结
1. 元组的元素不能修改
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用
字典
字典的创建
1. 我们可以通过{}、dict()来创建字典对象。
>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> b = dict(name='gaoqi',age=18,job='programmer')
>>> a = dict([("name","gaoqi"),("age",18)])
>>> c = {} #空的字典对象
>>> d = dict() #空的字典对象2. 通过 zip()创建字典对象
>>> k = ['name','age','job']
>>> v = ['gaoqi',18,'techer']
>>> d = dict(zip(k,v))
>>> d
{'name': 'gaoqi', 'age': 18, 'job': 'techer'}3. 通过 fromkeys 创建值为空的字典
>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}字典元素的访问
为了测试各种访问方法，我们这里设定一个字典对象：
a = {'name':'gaoqi','age':18,'job':'programmer'}
1. 通过 [键] 获得“值”。若键不存在，则抛出异常。
>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a['name']
'gaoqi'
>>> a['age']
18
>>> a['sex']
Traceback (most recent call last):
File "<pyshell#374>", line 1, in <module>
a['sex']
KeyError: 'sex'
2. 通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”。
>>> a.get('name')
'gaoqi'
>>> a.get('sex')
>>> a.get('sex','一个男人')
'一个男人'3. 列出所有的键值对
>>> a.items()
dict_items([('name', 'gaoqi'), ('age', 18), ('job', 'programmer')])4. 列出所有的键，列出所有的值
>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['gaoqi', 18, 'programmer'])5. len() 键值对的个数
6. 检测一个“键”是否在字典中
>>> a = {"name":"gaoqi","age":18}
>>> "name" in a
True字典元素添加、修改、删除
1. 给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。
>>>a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a['address']='西三旗 1 号院'
>>> a['age']=16
>>> a
{'name': 'gaoqi', 'age': 16, 'job': 'programmer', 'address': '西三旗 1 号院'}
2. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖。
>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> b = {'name':'gaoxixi','money':1000,'sex':'男的'}
>>> a.update(b)
>>> a
{'name': 'gaoxixi', 'age': 18, 'job': 'programmer', 'money': 1000, 'sex': '男的'}3. 字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”；
>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer'}
>>> b = a.pop('age')
>>> b
18
4. popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）。
>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> a
{'name': 'gaoqi', 'age': 18}
>>> a.popitem()
('age', 18)
>>> a
{'name': 'gaoqi'}练习
'''
字典使用人名作为键， 每个人的信息用另一个字典来表示， 其键” phone” 和” addr” 分
别表示他们的联系电话和地址， 重复输入3次， 最后将字典打印出来。
'''
dict = dict()
for i in range(3):
name = input("请输入姓名：")
phone = input("请输入电话：")
addr = input("请输入地址：")
myd = {}
myd['phone']= phone
myd['addr']= addr
dict[name] = myd
print(dict)zip
zip(列表 1，列表 2，...)将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象。
>>> a = [10,20,30]
>>> b = [40,50,60]
>>> c = [70,80,90]
>>> d = zip(a,b,c)
>>> list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]
异常
class NetworkError(RuntimeError):
def __init__(self, arg):
self.arg = arg
"""
def __str__(self):
return str(self.args)
"""
"""
def __str__(self):
return self.arg
"""
def connect():
raise NetworkError("Bad hostname")
try:
connect()
except NetworkError as err:
print(err)
finally:
print("this is finally")操作符重载
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector(%d, %d)' % (self.a, self.b)
def __add__(self, other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2)正则表达式基础
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。 |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
| \d | 数字 |
| [\u4e00\u9fa5] | 中文 |
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。 |
| ^ | 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 \^。 |
| * | 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。 |
| + | 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。 |
| ? | 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy" 中的 "do" 。? 等价于 {0,1}。 |
| {n} | n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。 |
| {n,} | n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。 |
| {n,m} | m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。 |
正则运用实例
import re
#匹配日期
date = "xxx出生于2019-10-1"
date = "xxx出生于2019年10月1日"
date = "xxx出生于2019/10/1"
date = "xxx出生于2019-10-01"
date = "xxx出生于2019-10"
pattern = ".*出生于(\d{4}[年/-]\d{1,2}([月/-]\d{1,2}|[月]$|$))"
reObj = re.match(pattern, date)
if reObj:
print(reObj.group(1))
print(reObj.group())综合运用实例
Python模拟自动取款机
'''
Name: 模拟自动取款机
Description: 数据临时存放在变量列表中，实现一个取款机上的存取款
模拟效果，包括登录、退出、查询余额、取款和存款功能
'''
# 账号信息列表
accoutList = [
{'accout':'442018001','name':'Allen','passwd':'123456','balance':100.00},
{'accout':'442018002','name':'Bonus','passwd':'abcdef','balance':100.00},
{'accout':'442018003','name':'Carrie','passwd':'hello','balance':200.00}]
# 显示所有账户信息（管理员权限）
def showAccout(accoutList):
'''
'''
if len(accoutList) == 0:
print("(I) No Data from Accout")
return
print("|{0:<10} | {1:<10} | {2:<10} | {3:<10}".format("accout",
"name","passwd","balance"))
print("-"*40)
for i in range(len(accoutList)):
print("|{0:<10} | {1:<10} | {2:<10} | {3:<10}".format(accoutList[i]['accout'],
accoutList[i]['name'],"******",accoutList[i]['balance']))
print("")
# 登录界面
def showLoginPage():
print("+-------------------------------+")
print("+ +")
print("+ ATM +")
print("+ +")
print("+-------------------------------+")
print(" （请插卡） ")
# 验证账号及密码
def checkAccout(accout, passwd):
for i in range(len(accoutList)):
if accout == accoutList[i]['accout'] and passwd == accoutList[i]['passwd']:
return i
# 没有匹配成功
return -1
# 初始化界面
def showMainPage():
print("")
print("="*13, "自动存取款系统", "="*13)
print("{0:1} {1:13} {2:15}".format(" ", "1.查询",
"2.取款"))
print("{0:1} {1:13} {2:15}".format(" ", "3.存款",
"4.退出系统"))
print("="*42)
# 自动取款机业务
def atmService(index):
key = input("请输入对应的选择：")
print("")
if key == "1":
print("="*14, "查询账户余额", "="*14)
#showAccout(accoutList)
print("> 账户姓名：", accoutList[index]['name'])
print("> 当前账户：", accoutList[index]['accout'])
print("> 当前余额：", accoutList[index]['balance'], end='\n\n')
return 0
elif key == "2":
print("="*14, "取款", "="*14)
money = input("请输入取款金额（元）：￥")
if int(money) > 0 and int(money) <= accoutList[index]['balance']:
accoutList[index]['balance'] -= int(money)
print("> 取款成功！*^_^*")
print("> 当前余额：", accoutList[index]['balance'], end='\n\n')
print("(I) 请取走现金并妥善保管")
return 0
else:
print("(E) 余额不足，取款失败")
return -1
elif key == "3":
print("="*14, "存款", "="*14)
money = input("> 存入金额（元）：￥")
accoutList[index]['balance'] += int(money)
print("> 存款成功！*^_^*")
print("> 当前余额：", accoutList[index]['balance'], end='\n\n')
return 0
elif key == "4":
print("="*18, "再见", "="*18)
return 1
else:
print("Try again!")
return -1
# 开始啦
showLoginPage()
accout = input("请输入账号：")
passwd = input("请输入密码：")
index = checkAccout(accout, passwd)
if index >= 0:
print("(I) 登录成功")
while True:
showMainPage()
if 1 == atmService(index):
break
input("按回车键继续：")
else:
print("(I) 登录失败，请检查账号和密码")
统计指定目录的大小
'''
Name: 统计指定目录的大小
'''
import os
# 自定义统计目录大小函数
def stat_dir_size(dir_path):
'''
功能: 统计目录大小
参数: 指定目录路径
返回：目录总大小（字节），错误返回-1
'''
total = 0
if os.path.isdir(dir_path):
dlist = os.listdir(dir_path)
for f in dlist:
subdir = os.path.join(dir_path, f)
if os.path.isfile(subdir):
total = total + os.path.getsize(subdir)
if os.path.isdir(subdir):
total = total + stat_dir_size(subdir)
return total
elif os.path.isfile(dir_path):
return os.path.getsize(dir_path)
else:
return -1
# 测试
path = input("请输入目录：")
size = stat_dir_size(path)
if size == -1:
print("(Error) \"{}\" is not a directory.".format(path))
else:
print("目录大小：", size, "Bytes")
1015
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
