标签：工厂方法 python3 成员 sqrt 存在 error 字符串拼接 dig python2
一 数据类型简介
计算机不仅仅能处理数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有整型，字符串，布尔型，列表，字典，元组等几种。
二 整型
2.1 数字类型的创建
Python3 支持 int、float、bool、complex（复数）。在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。像大多数语言一样，数值类型的赋值和计算都是很直观的。内置的 type() 函数可以用来查询变量所指的对象类型。
a=10 b=a b=666 print(a)#10 print(b)#666
2.2 数字类型的转换
var1=3.14 var2=5 var3=int(var1) var4=float(var2) print(var3,var4)
2.3 py内置数字函数
# abs(x) 返回数字的绝对值，如abs(-10) 返回 10 # ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5 # cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 # exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 # fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0 # floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4 # log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 # log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0 # max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。 # min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。 # modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 # pow(x, y) x**y 运算后的值。 # round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 # sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
三 字符串类型（string）
Python中的字符串用单引号(‘)或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。
3.1 创建字符串
var1 = ‘Hello World!‘ var2 = "Python Terry"
3.2 常用操作
重复输出字符串
print(‘hello‘*2)
通过索引获取字符串中字符
print(‘helloworld‘[2:]) 注：仅举一例，其余与列表切片相同
成员运算符（如果字符串中包含给定的字符返回 True）
print(‘el‘ in ‘hello‘)
格式化字符串输出
print(‘Terry is a good teacher‘) print(‘%s is a good teacher‘%‘Terry‘)
字符串拼接
a=‘123‘ b=‘abc‘ c=‘789‘ d1=a+b+c print(d1) # +效率低,该用join d2=‘‘.join([a,b,c]) print(d2)
3.3 python内置方法
# string.capitalize() 把字符串的第一个字符大写 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 # string.decode(encoding=‘UTF-8‘, errors=‘strict‘) 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 ‘ignore‘ 或 者‘replace‘ # string.encode(encoding=‘UTF-8‘, errors=‘strict‘) 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是‘ignore‘或者‘replace‘ # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 # string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False # string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False. # string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False. # string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False # string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False # string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False. # string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False # string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False # string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 # string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 # string.lower() 转换 string 中所有大写字符为小写. # string.lstrip() 截掉 string 左边的空格 # string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 # max(str) 返回字符串 str 中最大的字母。 # min(str) 返回字符串 str 中最小的字母。 # string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. # string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找. # string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始. # string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 # string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找. # string.rstrip() 删除 string 字符串末尾的空格. # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 # string.splitlines(num=string.count(‘\n‘)) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() # string.swapcase() 翻转 string 中的大小写 # string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) # string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 # string.upper() 转换 string 中的小写字母为大写
四 布尔型
一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写)。
4.1 基本操作
print(True) print(4>2) print(bool([3,4])) print(True+1) 布尔值经常用在条件判断中: age=18 if age>18:#bool(age>18) print(‘old‘) else: print(‘young‘)
4.2 与或非操作：
bool(1 and 0) bool(1 and 1) bool(1 or 0) bool(not 0)
五 列表（list）
List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表是写在方括号([])之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
5.1 基本操作
names_class2=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘] # print(names_class2[2]) # print(names_class2[0:3]) # print(names_class2[0:7]) # print(names_class2[-1]) # print(names_class2[2:3]) # print(names_class2[0:3:1]) # print(names_class2[3:0:-1]) # print(names_class2[:]) 注;左闭右开
#insert 方法用于将对象插入到列表任意一个位置，而append方法则用于在列表末尾追加新的对象 names_class2.append(‘alex‘) names_class2.insert(2,‘alvin‘) print(names_class2)
names_class2=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘] names_class2[3]=‘赵七‘ names_class2[0:2]=[‘wusir‘,‘alvin‘] print(names_class2)
names_class2.remove(‘alex‘) del names_class2[0] del names_class2 names_class2.pop()#注意,pop是有一个返回值的，即可以用一个变量接受
5.2 其他操作
count：count 方法统计某个元素在列表中出现的次数。
>>> [‘to‘, ‘be‘, ‘or‘, ‘not‘, ‘to‘, ‘be‘].count(‘to‘) 2 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] >>> x.count(1) 2 >>> x.count([1,2]) 1
extend：可以在列表的末尾一次性追加另一个序列中的多个值。
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6]
注：extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。>>> a=[1,2,3]
>>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6] >>> a + b [1, 2, 3, 4, 5, 6, 4, 5, 6] >>> a [1, 2, 3, 4, 5, 6] index：用于从列表中找出某个值第一个匹配项的索引位置。
names_class2=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘]
names_class2.index(‘李四‘)
reverse：将列表中的元素反向存放。
names_class2=[‘张三‘,‘李四‘,‘王五‘,‘赵六‘] names_class2.reverse() print(names_class2)
sort：用于在原位置对列表进行排序。
x = [4, 6, 2, 1, 7, 9] x.sort() # 顺序排序 x.sort(reverse=True)#逆序排序
深浅拷贝：浅拷贝（只拷贝第一层），深拷贝（克隆一份）。
注：再讲深浅拷贝之前，先说明：（不可变数据类型:数字,字符串,元组 可变类型:列表,字典）
（1）浅拷贝：
a=[[1,2],3,4] b=a[:]#b=a.copy() print(a,b) print(id(a),id(b)) print(‘*************‘) print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0])) print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0])) print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1])) print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1])) print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2])) print(‘___________________________________________‘) b[0][0]=8 print(a,b) print(id(a),id(b)) print(‘*************‘) print(‘a[0]:‘,id(a[0]),‘b[0]:‘,id(b[0])) print(‘a[0][0]:‘,id(a[0][0]),‘b[0][0]:‘,id(b[0][0])) print(‘a[0][1]:‘,id(a[0][1]),‘b[0][1]:‘,id(b[0][1])) print(‘a[1]:‘,id(a[1]),‘b[1]:‘,id(b[1])) print(‘a[2]:‘,id(a[2]),‘b[2]:‘,id(b[2]))<br><br><br>#outcome 运行结果： # [[1, 2], 3, 4] [[1, 2], 3, 4] # 4331943624 4331943752 # ************* # a[0]: 4331611144 b[0]: 4331611144 # a[0][0]: 4297375104 b[0][0]: 4297375104 # a[0][1]: 4297375136 b[0][1]: 4297375136 # a[1]: 4297375168 b[1]: 4297375168 # a[2]: 4297375200 b[2]: 4297375200 # ___________________________________________ # [[8, 2], 3, 4] [[8, 2], 3, 4] # 4331943624 4331943752 # ************* # a[0]: 4331611144 b[0]: 4331611144 # a[0][0]: 4297375328 b[0][0]: 4297375328 # a[0][1]: 4297375136 b[0][1]: 4297375136 # a[1]: 4297375168 b[1]: 4297375168 # a[2]: 4297375200 b[2]: 4297375200
解释如下图所示：
（2）深拷贝
import copy b=copy.deepcopy(a)
六 元组（tuple）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同。
6.1 创建元组
tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号
6.2 元组的作用
1 对于一些数据我们不想被修改，可以使用元组；
2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。
七 字典
字典（dictionary）是Python中另一个非常有用的内置数据类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
7.1 创建字典
dic1={‘name‘:‘alex‘,‘age‘:36,‘sex‘:‘male‘}
dic2=dict(((‘name‘,‘alex‘),))
print(dic1)
print(dic2)
7.2 基本操作
dic3={} dic3[‘name‘]=‘alex‘ dic3[‘age‘]=18 print(dic3)#{‘name‘: ‘alex‘, ‘age‘: 18} a=dic3.setdefault(‘name‘,‘yuan‘) b=dic3.setdefault(‘ages‘,22) print(a,b) print(dic3)
dic4={‘name‘: ‘alex‘, ‘age‘: 18,‘class‘:1}
# dic4.clear()
# print(dic4)
del dic4[‘name‘]
print(dic4)
a=dic4.popitem()
print(a,dic4)
# print(dic4.pop(‘age‘))
# print(dic4)
# del dic4
# print(dic4)
dic3={‘name‘: ‘alex‘, ‘age‘: 18}
dic3[‘name‘]=‘alvin‘
dic4={‘sex‘:‘male‘,‘hobby‘:‘girl‘,‘age‘:36}
dic3.update(dic4)
print(dic3)
dic3={‘name‘: ‘alex‘, ‘age‘: 18}
# print(dic3[‘name‘])
# print(dic3[‘names‘])
#
# print(dic3.get(‘age‘,False))
# print(dic3.get(‘ages‘,False))
print(dic3.items())
print(dic3.keys())
print(dic3.values())
print(‘name‘ in dic3)# py2: dic3.has_key(‘name‘)
print(list(dic3.values()))
7.3 其他操作
dict.fromkeys
d1=dict.fromkeys([‘host1‘,‘host2‘,‘host3‘],‘Mac‘) print(d1) d1[‘host1‘]=‘xiaomi‘ print(d1)
运行结果为：
{‘host2‘: ‘Mac‘, ‘host1‘: ‘Mac‘, ‘host3‘: ‘Mac‘}
{‘host2‘: ‘Mac‘, ‘host1‘: ‘xiaomi‘, ‘host3‘: ‘Mac‘}
#######
d2=dict.fromkeys([‘host1‘,‘host2‘,‘host3‘],[‘Mac‘,‘huawei‘]) print(d2) d2[‘host1‘][0]=‘xiaomi‘ print(d2)
运行结果为
{‘host2‘: [‘Mac‘, ‘huawei‘], ‘host1‘: [‘Mac‘, ‘huawei‘], ‘host3‘: [‘Mac‘, ‘huawei‘]}
{‘host2‘: [‘xiaomi‘, ‘huawei‘], ‘host1‘: [‘xiaomi‘, ‘huawei‘], ‘host3‘: [‘xiaomi‘, ‘huawei‘]}
d.copy() ：对字典 d 进行浅复制，返回一个和d有相同键值对的新字典。
字典的嵌套：三级菜单
sorted(dict) : 返回一个有序的包含字典所有key的列表。
dic={5:‘555‘,2:‘222‘,4:‘444‘}
print(sorted(dic))
字典的遍历
ic5={‘name‘: ‘alex‘, ‘age‘: 18}
for i in dic5:
print(i,dic5[i])
for items in dic5.items():
print(items)
for keys,values in dic5.items():
print(keys,values)
八 集合（set）
集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键。
注：可哈希是指集合的对象必须是不可变类型的（数字，字符串，元组）
8.1 集合的简单介绍
集合的创建：
由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建
s1 = set(‘alvin‘) s2= frozenset(‘yuan‘) print(s1,type(s1)) #{‘l‘, ‘v‘, ‘i‘, ‘a‘, ‘n‘} <class ‘set‘> print(s2,type(s2)) #frozenset({‘n‘, ‘y‘, ‘a‘, ‘u‘}) <class ‘frozenset‘>
集合分类：可变集合、不可变集合
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
li=[1,‘a‘,‘b‘] s =set(li) dic={s:‘123‘} #TypeError: unhashable type: ‘set‘
集合的作用：
li=[1,2,‘a‘,‘b‘] s =set(li) print(s) # {1, 2, ‘a‘, ‘b‘} li2=[1,2,1,‘a‘,‘a‘] s=set(li2) print(s) #{1, 2, ‘a‘}
1 in ,not in 2 集合等价与不等价(==, !=) 3 子集、超集 >>>s=set(‘alvinyuan‘) >>>s1=set(‘alvin‘) >>>print(‘v‘ in s) >>>print(s1<s)#返回True,还有另一种表达：s1.issubset(s) 判断s1是不是s的子集
>>>print(s>s1)#返回True，还有一种表达：s.issuperset(s1) 判断s是不是s1的超集 4 并集(|) 并集(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。 >>>s1=set(‘alvin‘) >>>s2=set(‘yuan‘) >>>s3=s1|s2 >>>print(s3) #{‘a‘, ‘l‘, ‘i‘, ‘n‘, ‘y‘, ‘v‘, ‘u‘} >>>print(s1.union(s2)) #{‘a‘, ‘l‘, ‘i‘, ‘n‘, ‘y‘, ‘v‘, ‘u‘} 5、交集(&) 与集合and等价，交集符号的等价方法是intersection() >>>s1=set(‘alvin‘) >>>s2=set(‘yuan‘) >>>s3=s1&s2 >>>print(s3) #{‘n‘, ‘a‘} >>>print(s1.intersection(s2)) #{‘n‘, ‘a‘} 6、差集(-)
等价方法是difference() >>>s1=set(‘alvin‘) >>>s2=set(‘yuan‘) >>>s3=s1-s2 >>>print(s3) #{‘v‘, ‘i‘, ‘l‘} >>>print(s1.difference(s2)) #{‘v‘, ‘i‘, ‘l‘} 7、对称差集(^) 对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference() >>>s1=set(‘alvin‘) >>>s2=set(‘yuan‘) >>>s3=s1^s2 >>>print(s3) #{‘l‘, ‘v‘, ‘y‘, ‘u‘, ‘i‘} >>>print(s1.symmetric_difference(s2)) #{‘l‘, ‘v‘, ‘y‘, ‘u‘, ‘i‘}
8.2 集合的其他操作
访问集合：由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。
s1 = set(‘alvin‘) print(‘a‘ in s1) print(‘b‘ in s1) #s1[1] #TypeError: ‘set‘ object does not support indexing for i in s1: print(i) # # True # False # v # n # l # i # a
更新集合：可使用以下内建方法来更新。
s.add()
s.update()
s.remove()
del:删除集合本身
注：只有可变集合才能更新
# s1 = frozenset(‘alvin‘) # s1.add(0) #AttributeError: ‘frozenset‘ object has no attribute ‘add‘ s2=set(‘alvin‘) s2.add(‘mm‘) print(s2) #{‘mm‘, ‘l‘, ‘n‘, ‘a‘, ‘i‘, ‘v‘} s2.update(‘HO‘)#添加多个元素 print(s2) #{‘mm‘, ‘l‘, ‘n‘, ‘a‘, ‘i‘, ‘H‘, ‘O‘, ‘v‘} s2.remove(‘l‘) print(s2) #{‘mm‘, ‘n‘, ‘a‘, ‘i‘, ‘H‘, ‘O‘, ‘v‘}
参考：https://www.cnblogs.com/yuanchenqi/articles/5782764.html
标签：工厂方法 python3 成员 sqrt 存在 error 字符串拼接 dig python2
原文地址：https://www.cnblogs.com/Terrypython/p/9231419.html
