int与long（整型）
对于python2.x来讲，int的长度取决于系统位数，如32位系统int的长度为：2的-31次方到2的31-1 次方，64位系统int长度为：2的-63次方到2的63-1次方，超出则为long型。long无限制，长度大小取决于系统。
对于python3.x里不区分int和long
float(浮点型)
用于处理实数，带小数点的数字。如：18.5
科学计数法：13.6E-2表示13.6×10的-4次方
真假值，1或0，True或False
如：“hello world”，下面介绍关于字符串的一些方法
# capitalize() 方法将首字母大写 first = "hello world!" print(first.capitalize()) 显示结果：----------- Hello world!
# count() 方法统计字符在字符串中出现次数 first = "hello world!" print(first.count("l")) # 统计“l”出现次数 print(first.count("l", 1, 5)) # 这里指定了查找的起始和截止位置 显示结果：------------ 3 2
# center() 方法将字符串居中，在其左右填充指定字符后的总长度为指定长度。 first = "hello world!" print(first.center(30, "*")) 显示结果：---------- *********hello world!*********
# endswith() 方法判断是否以指定字符或字符串结尾 e_mail = "hugh@126.com" print(e_mail.endswith(".com")) # 判断是否以.com结尾 显示结果：---------- True
# expandtabs() 方法将字符串中所含"\t"转换成指定数量的空格 first = "hello \tworld!" print(first.expandtabs(20)) 显示结果：------------ hello world!
# encode() 方法对字符进行编码成bytes类型 first = "世界你好！" print(first.encode(encoding='GB2312')) print(first.encode(encoding='utf-8')) 显示结果：------------ b'\xca\xc0\xbd\xe7\xc4\xe3\xba\xc3\xa3\xa1' b'\xe4\xb8\x96\xe7\x95\x8c\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'
# find() 方法查找一个字符串中，指定字符或字符串索引位置（索引从0开始），查找可指定起始和截止范围 first = "hello world!" print(first.find("l")) # 查找“l”在字符串中的位置 print(first.find("world")) # 查找“world”在字符串中的位置 print(first.find("l", 5, 10)) # 查找位置范围是5和10之间的“l”索引位置 显示结果：---------- 2 6 9
# lfind() 方法查找一个字符串中，从最左边指定字符或字符串索引位置（索引从0开始），查找可指定起始和截止范围
print(first.lfind("l")) # 输出：2
# rfind() 方法查找一个字符串中，从最右边指定字符或字符串索引位置（索引从0开始），查找可指定起始和截止范围
print(first.rfind("l")) # 输出：9
# 字符串切片 first = "my hello world!" print(first[first.find("hello"):]) 显示结果：--------- hello world!
# format() 方法格式化字符串 string = "{name} is {age}" print(string.format(name="hugh", age=28)) 显示结果：---------- hugh is 28
# format_map() 方法格式化字符串，用字典方式 string = "{name} is {age}" print(string.format_map({"name": "hugh", "age": 28})) 显示结果：---------- hugh is 28
# index() 方法返回指定字符或字符串的索引位置（索引从0开始），并可以指定范围。
first = "hello world!" print(first.index("o")) print(first.index("o", 6, 10)) # 指定范围为位置索引从6-10 显示结果：------------ 4 7
# isalnum() 方法检测字符串是否由字母和数字组成。 str = "this2009"; print(str.isalnum()); str = "this is string example....wow!!!"; print(str.isalnum()); 显示结果：--------- True False
# isalpha() 方法检测字符串是否只由字母组成。 str = "this"; # No space & digit in this string print(str.isalpha()) str = "this is string example....wow!!!"; print(str.isalpha())
显示结果：---------
True
False
''' isdigit() True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字 False: 汉字数字 Error: 无 isdecimal() True: Unicode数字，，全角数字（双字节） False: 罗马数字，汉字数字 Error: byte数字（单字节） isnumeric() True: Unicode数字，全角数字（双字节），罗马数字，汉字数字 False: 无 Error: byte数字（单字节） ''' num = "1" #unicode num.isdigit() # True num.isdecimal() # True num.isnumeric() # True num = "1" # 全角 num.isdigit() # True num.isdecimal() # True num.isnumeric() # True num = b"1" # byte num.isdigit() # True num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal' num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric' num = "IV" # 罗马数字 num.isdigit() # True num.isdecimal() # False num.isnumeric() # True num = "四" # 汉字 num.isdigit() # False num.isdecimal() # False num.isnumeric() # True
# isidentifier() 方法判断是否合法标识符（变量名） print("1to".isidentifier()) # False print("a1".isidentifier()) # True
# islower() 方法判断是否是小写 print("abC".islower()) # False print("abc".islower()) # True
# lower() 方法用于将字符串中的大写字母转成小写
print("abC".lower()) # 输出：abc
# isupper() 方法判断是否是大写 print("abC".isupper()) # False print("ABC".isupper()) # True
# upper() 方法将字符串中的小写字母都转成大写 print("abC".upper()) # 输出：ABC
# istitle() 方法判断是否是标题，也就是每个单词的首字母是否大写 print("This My Book".istitle()) # True
# title() 方法是将字符串中的首字母进行大写处理 print("this my book".title()) # 输出：This My Book
# isprintable() 方法是判断否可以打印，比如linux中的tty等设备文件是无法打印的 first.isprintable()
# join() 方法实现按指定字符连接一个列表元素 print("+".join(["1", "2", "3"])) # 输出：1+2+3
# ljust() 方法实现将字符串置左侧，右边填充指定的字符到指定长度 print("super man".ljust(30, "*")) # 输出：super man*********************
# rjust() 方法实现将字符串置左侧，右边填充指定的字符到指定长度 print("super man".人just(30, "*")) # 输出：*********************super man
# lower() 方法是将字符串中大写字母变小写字母 print("abC".lower()) #输出：abc # upper() 方法是将字符串中小写字母变大写字母 print("abC".upper()) # 输出：ABC
# strip() 方法是从字符串两边去除空格、回车、tab print("\n \tMy god! \n".strip()) # 输出：My god！ # lstrip() 方法是从字符串左边去除空格、回车、tab # rstrip() 方法是从字符串右边去除空格、回车、tab
# maketrans() 方法预设一种对应，然后可以将字符串用translate()传进对应关系，将对应进行转换（将前面出现的转换成后面出现的） m = str.maketrans("abcdef", "123456") print("today is Monday".translate(m)) # 输出：to41y is Mon41y
# partition() 方法用来根据指定的分隔符将字符串进行分割。 # 如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。 print("http://www.baidu.com".partition("//")) # 输出：('http:', '//', 'www.baidu.com')
# rpartition() 方法用从最右侧指定的分隔符将字符串进行分割。partition()默认是从字符串最左侧的指定分割符进行分割
# replace() 方法是用于替换，参数分别为原字符、新字符、替换数量（默认全部替换） print("abcda".replace("a", "1", 1)) # 输出：1bcda
# split() 方法是指定分隔符来分割一个字符串输出成列表，如果指定第二个参数，则只从左侧指定次数进行分割。 print("123,456,789,0a".split(",", 2)) # 输出：['123', '456', '789,0a'] # rsplit() 方法同split(),只是从右侧开始分割 print("123,456,789,0a".split(",", 2)) # 输出：['123,456', '789', '0a'] # splitlines() 方法用于按换行进行分割 print("123\n456\n567".splitlines()) # 输出：['123', '456', '567']
# swapcase() 方法作用是将字符串中字母大写转换成小写，小写转换成大写 print("My name is Hugh".swapcase()) # 输出：mY NAME IS hUGH
# zfill() 方法可以在字符串中填充0，填充后的字符串长度为指定参数 print("Hello".zfill(10)) # 输出：00000Hello
详细说明：http://www.cnblogs.com/zanjiahaoge666/p/6402907.html
eg1：
strtest = "星球崛起" print(strtest.encode(encoding='utf-8')) # 编码为“utf-8”，bytes类型 print(strtest.encode(encoding='utf-8').decode(encoding='utf-8')) # 解码 显示结果：----------- b'\xe6\x98\x9f\xe7\x90\x83\xe5\xb4\x9b\xe8\xb5\xb7' 星球崛起
查找（获取与切片）：
name = ["zhangsan", "lisi", "wangwu", "duanliu", "jiaba", "qianjiu"] print(name[0]) # 元素位置从0开始 print(name[-1]) # 取最后一个元素 print(name[1:3]) # 切片，采取顾头不顾尾 print(name[-2:]) # 取最后两个元素 print(name[:2]) # 取前两个元素 print(name[0:-1:2]) # 步长切片（步长为2），从第一个到最后一个元素采取隔一取一，这里可以缺省开始和结束位置，如name[::2] 显示结果：-------------------- zhangsan qianjiu ['lisi', 'wangwu'] ['jiaba', 'qianjiu'] ['zhangsan', 'lisi'] ['zhangsan', 'wangwu', 'jiaba']
增加（加入列表）：
name = ["zhangsan", "lisi", "wangwu", "duanliu"] name.append("jiaqi") # 在列表后追加 print(name) name.insert(2, "qianba") # 在列表中插入元素，2为插入的位置 print(name) 显示结果：--------- ['zhangsan', 'lisi', 'wangwu', 'duanliu', 'jiaqi'] ['zhangsan', 'lisi', 'qianba', 'wangwu', 'duanliu', 'jiaqi']
修改（修改列表元素）：
name = ["zhangsan", "lisi", "wangwu", "duanliu"] name[1] = "super" print(name) 显示结果：--------- ['zhangsan', 'super', 'wangwu', 'duanliu']
删除（从列表删除元素）：
三种删除方式：
- remove：通过元素值删除
name = ["zhangsan", "lisi", "wangwu", "duanliu"] name.remove("lisi") print(name) 显示结果：----------- ['zhangsan', 'wangwu', 'duanliu']
- del：通过位置删除
name = ["zhangsan", "lisi", "wangwu", "duanliu"] del name[1] print(name) 显示结果：------------ ['zhangsan', 'wangwu', 'duanliu']
- pop：默认删除队列末尾元素，如果输入下标为删除指定位置元素同del
name = ["zhangsan", "lisi", "wangwu", "duanliu"] name.pop() print(name) 显示结果：------------- ['zhangsan', 'lisi', 'wangwu']
获取元素位置：
name = ["zhangsan", "lisi", "wangwu", "duanliu"] print(name.index("wangwu")) 显示结果：------------ 2
统计重复元素出现次数：
name = ["zhangsan", "lisi", "wangwu", "duanliu", "lisi"] print(name.count("lisi")) 显示结果：------------ 2
清空列表：
name = ["zhangsan", "lisi", "wangwu", "duanliu"] print(name.clear()) 显示结果：------------ []
列表反转：
name = ["zhangsan", "lisi", "wangwu", "duanliu"] name.reverse() print(name) 显示结果：------------- ['duanliu', 'wangwu', 'lisi', 'zhangsan']
列表排序：
排序规则依：是按ASCII字符表顺序，依次为特殊字符、数字、大写字符、小写字符
name = ["4zhangsan", "#lisi", "wangwu", "Duanliu"] name.sort() print(name) 显示结果：------------- ['#lisi', '4zhangsan', 'Duanliu', 'wangwu']
列表扩展：
name = ["4zhangsan", "#lisi", "wangwu", "Duanliu"] name2 = [1, 2, 3, 4] name.extend(name2) print(name,name2) 显示结果：------------- ['4zhangsan', '#lisi', 'wangwu', 'Duanliu', 1, 2, 3, 4] [1, 2, 3, 4] # 扩展name后，name2依然存在
列表复制：
- copy为浅复制（只进行第一层复制，对于列表等对象copy的是内存地址，不会copy对象内的元素）。
name = ["zhangsan", "lisi", "wangwu", [1, 2],"duanliu"] name2 = name.copy() name[2] = "jiaqi" name[3][0] = 5 print("name:",name) print("name2:",name2) 显示结果：------------- name: ['zhangsan', 'lisi', 'jiaqi', [5, 2], 'duanliu'] name2: ['zhangsan', 'lisi', 'wangwu', [5, 2], 'duanliu'] # copy后，修改name的“lisi"普通元素为jiaqi，name2普通元素不受影响仍为jiaqi。但是修改了name中列表元素1变成5，则name2中的列表元素也相应修改成5.因为列表为内存地址
浅copy三种形式：
import copy person = ['name', ['a', 2]] p1 = copy.copy(person) # 形式1，copy模块 p2 = person[:] # 形式2，通过空切片 p3 = list(person) # 形式3，工厂模式
浅copy的应用场景：
# 可以作为模板使用，比如zhansan和lisi公用一个帐号的情景。无论zhangsan还是lisi只要有存取，共同帐号的存款额度就应该变化 person = ['name', ['saving', 100]] p1 = person[:] p2 = person[:] p1[0] = 'zhangsan' p2[0] = 'lisi' p1[1][1] = 50 print(p1,p2) 输出结果：---------- ['zhangsan', ['saving', 50]] ['lisi', ['saving', 50]]
- deepcopy为深copy，完全复制（使用此功能需要引入copy模块）。慎用，因为此copy会完全复制占用大量内存。
import copy name = ["zhangsan", "lisi", "wangwu", [1, 2],"duanliu"] name2 = copy.deepcopy(name) # 此处如果用name2=copy.copy(name)的话，效果和浅copy是一样的。 name[2] = "jiaqi" name[3][0] = 5 print("name:",name) print("name2:",name2) 显示结果：----------- name: ['zhangsan', 'lisi', 'jiaqi', [5, 2], 'duanliu'] name2: ['zhangsan', 'lisi', 'wangwu', [1, 2], 'duanliu']
# 深copy后name中的列表元素被修改，不会影响到name2的列表元素。
列表成员显示：
name = ["zhangsan", "lisi", "wangwu"] for i in name: print(i) 显示结果：--------------- zhangsan lisi wangwu
元组创建后无法修改，从本质上讲就是一个只读列表。它只有两个方法一个是count一个是index。语法格式：name = ("zhangsan", "李四", "wangwu")
key-value形式存储数据，并且是无序存储。格式如下：
info = {'name1': 'zhangsan', 'name2': 'lisi', 'name3': 'wangwu'}
字典的增删改查操作：
info = {'name1': 'zhangsan', 'name2': 'lisi', 'name3': 'wangwu'}
# 查找
print(info.get('name2')) # 输出：lisi
print(info.get('name7')) # 输出：None，如果key不存在将返回None
print(info.get('name7','super')) # 输出：super，如果key不存在将返回后面的参数super
print(info['name2']) # 输出：lisi，不建议这种写法
print('name2' in info) # 输出：True，如果不存在输出False。在python2.x中使用info.has_key('name2')
# 修改，key存在就是修改
info['name3'] = '黄飞鸿'
print(info) #输出：{'name3': '黄飞鸿', 'name2': 'lisi', 'name1': 'zhangsan'}
# 增加，如果key存在就是修改，key不存在就是增加
info['name4'] = '李小龙'
print(info) # 输出：{'name3': '黄飞鸿', 'name4': '李小龙', 'name2': 'lisi', 'name1': 'zhangsan'}
# 删除三种方法：
info.pop('name3') # 标准删除方式
print(info) # 输出：{'name2': 'lisi', 'name1': 'zhangsan'}
del info['name4'] # Python通用删除方式
print(info) # 输出：{'name1': 'zhangsan', 'name2': 'lisi', 'name3': '黄飞鸿'}
info.popitem() # 此方法为随机删除字典中的元素
print(info) # 输出：{'name2': 'lisi'}
其他常用操作：
info = {'name1': 'zhangsan', 'name2': 'lisi', 'name3': 'wangwu'}
# keys() 方法只显示key
print(info.keys()) # dict_keys(['name1', 'name3', 'name2'])
# values() 方法只显示value
print(info.values())
# setdefault() 方法是如果是字典所含的key，则不改变，并返回所含key的value。如果不是所含key，则增加key-value
info.setdefault('name2', '张三丰')
print(info) # 输出：{'name2': 'lisi', 'name1': 'zhangsan', 'name3': 'wangwu'}
info.setdefault('name7', '张三丰')
print(info) # 输出：{'name2': 'lisi', 'name7': '张三丰', 'name1': 'zhangsan', 'name3': 'wangwu'}
# update() 方法作用是合并字典(传进去的字典合并到现有的字典)，如果有相同的key，后者（传进去的字典）覆盖掉前者的value
second = {'name1': '无极', 1: 33, '2': 64}
info.update(second)
print(info) # 输出：{1: 33, 'name1': '无极', '2': 64, 'name2': 'lisi', 'name3': 'wangwu', 'name7': '张三丰'}
# items() 方法是将字典转换成列表，key与value形成一个元组形式的列表元素
print(info.items()) # 输出：dict_items([('2', 64), ('name1', '无极'), ('name3', 'wangwu'), (1, 33), ('name2', 'lisi'), ('name7', '张三丰')])
# fromkeys() 方法用于初始化字典，预设key及valus，value为一个初始缺省值
test = dict.fromkeys([1, 2, 3], [1, {"name": "superman"}, 'nn'])
print(test) #输出：{1: [1, {'name': 'superman'}, 'nn'], 2: [1, {'name': 'superman'}, 'nn'], 3: [1, {'name': 'superman'}, 'nn']}
# 引申出一个fromkeys的问题：对于初始化值value是对象的，虽然初始化多个key-value但其value为同一地址，修改也是修改同一地址下的值。如同浅拷贝
test[2][1]['name'] = '孙悟空'
print(test) # 输出：{1: [1, {'name': '孙悟空'}, 'nn'], 2: [1, {'name': '孙悟空'}, 'nn'], 3: [1, {'name': '孙悟空'}, 'nn']}
字典的循环：
# 效率较高，直接通过key获取value for i in dic: print(i, dic[i]) # 效率较低，先将字典转换成列表，然后再取以元组形式的key和value值 for k, v in dic.items(): print(k, v) 输出：-------------- 1 zhangsan 2 lisi 3 wangwu
集合是不重复的，无序的数据集合。两个重要作用是去重和关系测试（交、差、并等）
关系测试：
# 去重，转换成集合用set() a = [1, 2, 5, 7, 8, 2] a = set(a) print(a) # 输出：{8, 1, 2, 5, 7} # 交集，intersection()或& b = [2, 5, 9, 10] b = set(b) print(a.intersection(b)) # 输出：{2, 5} print(a & b) # 输出：{2, 5} # 并集，union()或| print(a.union(b)) # 输出：{1, 2, 5, 7, 8, 9, 10} print(a | b) # 输出：{1, 2, 5, 7, 8, 9, 10} # 差集，difference()或- print(a.difference(b)) # 输出：{1, 7, 8}，以a为基准只保留a里面有，而b里面没有的。 print(a - b) # 输出：{1, 7, 8}，以a为基准只保留a里面有，而b里面没有的。 print(b.difference(a)) # 输出：{9, 10} print(b - a) # 输出：{9, 10} # 子集，issubset() print(b.issubset(a)) # 输出：False，b是a的子集判断 c = set([2, 5]) print(c.issubset(a)) # 输出：True，c是a的子集判断 # 父集，issuperset() print(b.issuperset(c)) # 输出：True，b是c的父集判断 # 对称差集，ymmetric_difference()或^，取出互相都没有的部分 print(a.symmetric_difference(b)) # 输出：{1, 7, 8, 9, 10} print(a ^ b) # 输出：{1, 7, 8, 9, 10} # 非交集判断，无交集返回True，有交集返回Flase d = set([10, 11]) print(c.isdisjoint(d)) # True print(a.isdisjoint(b)) # False
集合操作：
# 添加 set1 = set([1, 2, 3]) # 添加一个元素 set1.add(4) print(set1) # 输出：{1, 2, 3, 4} set1.update([5, 6]) # 添加多个元素 print(set1) # 输出：{1, 2, 3, 4, 5, 6} # 删除，remove()方法删除指定元素，如果集合无此元素将报错 set1.remove(2) print(set1) # 输出：{1, 3, 4, 5, 6} # 删除，discard()方法删除指定元素，如果集合无此元素不会报错 set1.discard(3) print(set1) # 输出：{1, 4, 5, 6} # 随机删除，并返回被删除元素 print(set1.pop()) # 输出：1 # 长度 print(len(set1)) # 输出：3 # 成员测试 print(1 in set1) # 输出：False print(2 not in set1) # 输出：True
浙公网安备 33010602011771号