jackfrued
/
LearnPython
mirror of https://github.com/jackfrued/LearnPython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

update python_base

master
zhangjie 2016-10-17 11:47:41 +08:00
parent 8be49fcbfd
commit 56865439c2
1 changed files with 113 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
python_base.py
View File

@ -2,7 +2,7 @@
"""类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算""" """类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算"""
#-- 寻求帮助： #-- 寻求帮助:
dir(obj) # 简单的列出对象obj所包含的方法名称，返回一个字符串列表 dir(obj) # 简单的列出对象obj所包含的方法名称，返回一个字符串列表
help(obj.func) # 查询obj.func的具体介绍和用法 help(obj.func) # 查询obj.func的具体介绍和用法
@ -27,7 +27,7 @@
0o177, 0x9ff, 0X9FF, 0b101010 # 八进制、十六进制、二进制数字 0o177, 0x9ff, 0X9FF, 0b101010 # 八进制、十六进制、二进制数字
3+4j, 3.0+4.0j, 3J # 复数常量，也可以用complex(real, image)来创建 3+4j, 3.0+4.0j, 3J # 复数常量，也可以用complex(real, image)来创建
hex(I), oct(I), bin(I) # 将十进制数转化为十六进制、八进制、二进制表示的“字符串” hex(I), oct(I), bin(I) # 将十进制数转化为十六进制、八进制、二进制表示的“字符串”
int(str, base) # 将字符串转化为整数，base为进制数 int(string, base) # 将字符串转化为整数，base为进制数
# 2.x中，有两种整数类型：一般整数（32位）和长整数（无穷精度）。可以用l或L结尾，迫使一般整数成为长整数 # 2.x中，有两种整数类型：一般整数（32位）和长整数（无穷精度）。可以用l或L结尾，迫使一般整数成为长整数
float('inf'), float('-inf'), float('nan') # 无穷大, 无穷小, 非数 float('inf'), float('-inf'), float('nan') # 无穷大, 无穷小, 非数
@ -44,7 +44,7 @@
x<<y, x>>y # 位操作：x左移、右移y位 x<<y, x>>y # 位操作：x左移、右移y位
+, -, *, /, //, %, ** # 真除法、floor除法：返回不大于真除法结果的整数值、取余、幂运算 +, -, *, /, //, %, ** # 真除法、floor除法：返回不大于真除法结果的整数值、取余、幂运算
-x, +x, ~x # 一元减法、识别、按位求补（取反） -x, +x, ~x # 一元减法、识别、按位求补（取反）
x[i], x[i:j:k], x(……) # 索引、分片、调用 x[i], x[i:j:k] # 索引、分片、调用
int(3.14), float(3) # 强制类型转换 int(3.14), float(3) # 强制类型转换
#-- 整数可以利用bit_length函数测试所占的位数 #-- 整数可以利用bit_length函数测试所占的位数
@ -78,14 +78,14 @@
""" """
s = set([3,5,9,10]) # 创建一个数值集合，返回{3, 5, 9, 10} s = set([3,5,9,10]) # 创建一个数值集合，返回{3, 5, 9, 10}
t = set("Hello") # 创建一个唯一字符的集合返回{} t = set("Hello") # 创建一个唯一字符的集合返回{}
a = t | s t.union(s) # t 和 s的并集 a = t | s; t.union(s) # t 和 s的并集
b = t & s t.intersection(s) # t 和 s的交集 b = t & s; t.intersection(s) # t 和 s的交集
c = t – s t.difference(s) # 求差集（项在t中, 但不在s中） c = t – s; t.difference(s) # 求差集（项在t中, 但不在s中）
d = t ^ s t.symmetric_difference(s) # 对称差集（项在t或s中, 但不会同时出现在二者中） d = t ^ s; t.symmetric_difference(s) # 对称差集（项在t或s中, 但不会同时出现在二者中）
t.add('x') t.remove('H') # 增加/删除一个item t.add('x'); t.remove('H') # 增加/删除一个item
t.update([10,37,42]) # 利用[......]更新s集合 t.update([10,37,42]) # 利用[......]更新s集合
x in s, x not in s # 集合中是否存在某个值 x in s, x not in s # 集合中是否存在某个值
s.issubset(t) s.issuperset(t) s.copy() s.discard(x) s.clear() s.issubset(t); s.issuperset(t); s.copy(); s.discard(x); s.clear()
{x**2 for x in [1, 2, 3, 4]} # 集合解析，结果：{16, 1, 4, 9} {x**2 for x in [1, 2, 3, 4]} # 集合解析，结果：{16, 1, 4, 9}
{x for x in 'spam'} # 集合解析，结果：{'a', 'p', 's', 'm'} {x for x in 'spam'} # 集合解析，结果：{'a', 'p', 's', 'm'}
@ -103,7 +103,7 @@
#-- 布尔类型bool #-- 布尔类型bool
type(True) # 返回<class 'bool'> type(True) # 返回<class 'bool'>
isinstance(False, int) # bool类型属于整形，所以返回True isinstance(False, int) # bool类型属于整形，所以返回True
True == 1, True is 1 # 输出(True, False) True == 1; True is 1 # 输出(True, False)
#-- 动态类型简介 #-- 动态类型简介
""" """
@ -135,20 +135,21 @@
','.join(['a', 'b', 'c']) # 字符串输出，结果：a,b,c ','.join(['a', 'b', 'c']) # 字符串输出，结果：a,b,c
#-- 内置str处理函数： #-- 内置str处理函数：
str.upper() str.lower() str.swapcase() str.capitalize() str.title() # 全部大写，全部小写、大小写转换，首字母大写，每个单词的首字母都大写 str1 = "stringobject"
str.ljust(width) # 获取固定长度，右对齐，左边不够用空格补齐 str1.upper(); str1.lower(); str1.swapcase(); str1.capitalize(); str1.title() # 全部大写，全部小写、大小写转换，首字母大写，每个单词的首字母都大写
str.rjust(width) # 获取固定长度，左对齐，右边不够用空格补齐 str1.ljust(width) # 获取固定长度，右对齐，左边不够用空格补齐
str.center(width) # 获取固定长度，中间对齐，两边不够用空格补齐 str1.rjust(width) # 获取固定长度，左对齐，右边不够用空格补齐
str.zfill(width) # 获取固定长度，右对齐，左边不足用0补齐 str1.center(width) # 获取固定长度，中间对齐，两边不够用空格补齐
str.find('t',start,end) # 查找字符串，可以指定起始及结束位置搜索 str1.zfill(width) # 获取固定长度，右对齐，左边不足用0补齐
str.rfind('t') # 从右边开始查找字符串 str1.find('t',start,end) # 查找字符串，可以指定起始及结束位置搜索
str.count('t') # 查找字符串出现的次数 str1.rfind('t') # 从右边开始查找字符串
str1.count('t') # 查找字符串出现的次数
#上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1 #上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1
str.replace('old','new') # 替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new str1.replace('old','new') # 替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new
str.strip() str.lstrip() str.rstrip() str.strip('d') str.lstrip('d') str.rstrip('d') str1.strip(); str1.lstrip(); str1.rstrip(); str1.strip('d'); str1.lstrip('d'); str1.rstrip('d')
str.startswith('start') # 是否以start开头 str1.startswith('start') # 是否以start开头
str.endswith('end') # 是否以end结尾 str1.endswith('end') # 是否以end结尾
str.isalnum() str.isalpha() str.isdigit() str.islower() str.isupper() # 判断字符串是否全为字符、数字、大写、小写 str1.isalnum(); str1.isalpha(); str1.isdigit(); str1.islower(); str1.isupper() # 判断字符串是否全为字符、数字、大写、小写
#-- 三重引号编写多行字符串块，并且在代码折行处嵌入换行字符\n #-- 三重引号编写多行字符串块，并且在代码折行处嵌入换行字符\n
mantra = """hello world mantra = """hello world
@ -157,7 +158,7 @@
# mantra为"""hello world \n hello python \n hello my friend""" # mantra为"""hello world \n hello python \n hello my friend"""
#-- 索引和分片： #-- 索引和分片：
S[0], S[len(S) – 1], S[-1] # 索引 S[0], S[len(S)–1], S[-1] # 索引
S[1:3], S[1:], S[:-1], S[1:10:2] # 分片，第三个参数指定步长 S[1:3], S[1:], S[:-1], S[1:10:2] # 分片，第三个参数指定步长
#-- 字符串转换工具： #-- 字符串转换工具：
@ -168,9 +169,9 @@
bin(13), oct(13), hex(13) # 将整数转化为二进制/八进制/十六进制字符串，返回('1001', '0o15', '0xd') bin(13), oct(13), hex(13) # 将整数转化为二进制/八进制/十六进制字符串，返回('1001', '0o15', '0xd')
#-- 另类字符串连接 #-- 另类字符串连接
name = "wang" "hong" #单行，name = "wanghong" name = "wang" "hong" # 单行，name = "wanghong"
name = "wang" \ name = "wang" \
"hong" #多行，name = "wanghong" "hong" # 多行，name = "wanghong"
#-- Python中的字符串格式化实现1--字符串格式化表达式 #-- Python中的字符串格式化实现1--字符串格式化表达式
""" """
@ -249,7 +250,7 @@
D = dict(name = 'tom', age = 12) # {'age': 12, 'name': 'tom'} D = dict(name = 'tom', age = 12) # {'age': 12, 'name': 'tom'}
D = dict([('name', 'tom'), ('age', 12)]) # {'age': 12, 'name': 'tom'} D = dict([('name', 'tom'), ('age', 12)]) # {'age': 12, 'name': 'tom'}
D = dict(zip(['name', 'age'], ['tom', 12])) # {'age': 12, 'name': 'tom'} D = dict(zip(['name', 'age'], ['tom', 12])) # {'age': 12, 'name': 'tom'}
D.keys() D.values() D.items() # 字典键、值以及键值对 D.keys(); D.values(); D.items() # 字典键、值以及键值对
D.get(key, default) # get函数 D.get(key, default) # get函数
D.update(D_other) # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据 D.update(D_other) # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据
D.pop(key, [D]) # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常 D.pop(key, [D]) # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常
@ -356,14 +357,14 @@
#-- Python的while语句或者for语句可以带else语句 当然也可以带continue/break/pass语句 #-- Python的while语句或者for语句可以带else语句 当然也可以带continue/break/pass语句
while a > 1: while a > 1:
...... anything
else: else:
...... anything
# else语句会在循环结束后执行，除非在循环中执行了break，同样的还有for语句 # else语句会在循环结束后执行，除非在循环中执行了break，同样的还有for语句
for i in range(5): for i in range(5):
...... anything
else: else:
...... anything
#-- for循环的元组赋值 #-- for循环的元组赋值
for (a, b) in [(1, 2), (3, 4)]: # 最简单的赋值 for (a, b) in [(1, 2), (3, 4)]: # 最简单的赋值
@ -501,7 +502,7 @@
def f(a, b, c): print(a, b, c) def f(a, b, c): print(a, b, c)
f(1, 2, 3) # 参数位置匹配 f(1, 2, 3) # 参数位置匹配
f(1, c = 3, b = 2) # 参数关键字匹配 f(1, c = 3, b = 2) # 参数关键字匹配
def f(a, b = 1, c = 2): print(a, b, c) def f(a, b=1, c=2): print(a, b, c)
f(1) # 默认参数匹配 f(1) # 默认参数匹配
f(1, 2) # 默认参数匹配 f(1, 2) # 默认参数匹配
f(a = 1, c = 3) # 关键字参数和默认参数的混合 f(a = 1, c = 3) # 关键字参数和默认参数的混合
@ -516,7 +517,7 @@
def f(**args): print(args) # 在字典中收集不匹配的关键字参数 def f(**args): print(args) # 在字典中收集不匹配的关键字参数
f(a = 1, b = 2) # 输出{'a':1, 'b':2} f(a = 1, b = 2) # 输出{'a':1, 'b':2}
def f(a, *b **c): print(a, b, c) # 两者混合使用 def f(a, *b **c): print(a, b, c) # 两者混合使用
f(1, 2, 3, x = 4, y = 5) # 输出1, (2, 3), {'x':4, 'y':5} f(1, 2, 3, x=4, y=5) # 输出1, (2, 3), {'x':4, 'y':5}
#-- 函数调用时的参数解包: * 和 ** 分别解包元组和字典 #-- 函数调用时的参数解包: * 和 ** 分别解包元组和字典
func(1, *(2, 3)) <==> func(1, 2, 3) func(1, *(2, 3)) <==> func(1, 2, 3)
@ -823,12 +824,12 @@
def action(self): pass def action(self): pass
x = Super() # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action x = Super() # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action
#-- # OOP和继承: "is - a"的关系 #-- # OOP和继承: "is-a"的关系
class A(B): class A(B):
pass pass
a = A() a = A()
isinstance(a, B) # 返回True, A是B的子类 a也是B的一种 isinstance(a, B) # 返回True, A是B的子类 a也是B的一种
# OOP和组合: "has- a"的关系 # OOP和组合: "has-a"的关系
pass pass
# OOP和委托: "包装"对象 在Python中委托通常是以"__getattr__"钩子方法实现的, 这个方法会拦截对不存在属性的读取 # OOP和委托: "包装"对象 在Python中委托通常是以"__getattr__"钩子方法实现的, 这个方法会拦截对不存在属性的读取
# 包装类(或者称为代理类)可以使用__getattr__把任意读取转发给被包装的对象 # 包装类(或者称为代理类)可以使用__getattr__把任意读取转发给被包装的对象
@ -1308,5 +1309,4 @@
lists[0].append(3) # 结果为[[3], [], []] lists[0].append(3) # 结果为[[3], [], []]
lists[1].append(6) # 结果为[[3], [6], []] lists[1].append(6) # 结果为[[3], [6], []]
lists[2].append(9) # 结果为[[3], [6], [9]] lists[2].append(9) # 结果为[[3], [6], [9]]
lists = [[[] for j in range(4)] for i in range(3)] lists = [[[] for j in range(4)] for i in range(3)] # 3行4列，且每一个元素为[]
lists # 3行4列，且每一个元素为[]