Python入门篇-基础数据类型之整型（int），字符串（str），字节（bytes），列表（list）和切片（slice）
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.Python内置数据结构分类
1>.数值型
如 ：int,float,complex,bool
2>.序列对象
字符串：str
列表：list
元组：tuple
3>.键值对
集合：set 字典：dict
二.数值型
1>.数值型概述
int、float、complex、bool都是class，、5.0、+3j都是对象即实例。
int：
python3的int就是长整型，且没有大小限制，受限于内存区域的大小。
float：
有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。
complex：
有实数和虚数部分组成，实数和虚数部分都是浮点数，+.2J。
bool：
int的子类，仅有2个实例True、False对应1和0，可以和整数直接运算。
2>.类型转换
int(x) 返回一个整数 float(x) 返回一个浮点数 complex(x)、complex(x,y) 返回一个复数 bool(x) 返回布尔值，前面讲过False等价的对象
3>.数字的处理函数
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com import math #取整
print(math.floor(3.1))
print(math.floor(3.6))
#取整并加1
print(math.ceil(5.1))
print(math.ceil(5.6))
#查看PI的值
print(math.pi)
#查看自然常数
print(math.e) #四舍六入，五往偶数靠拢,并非四舍五入.简称：“四舍六入五取偶”
print(round(13.1))
print(round(13.6))
print(round(23.5))
print(round(26.5)) #取最小值
print(min(10,20))
#取最大值
print(max(100,200))
#取平方数
print(pow(5,2))
#二进制表示10
print(bin(10))
#八进制表示10
print(oct(10))
#十六进制表示10
print(hex(10))
3.141592653589793
2.718281828459045 0b1010
0o12
0xa
以上代码输出结果戳我可以查看哟~
4>.类型判断
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #定义变量
Name = "Jason Yin"
Age = 18 #判断数据的类型
print(type(Name))
print(type(Age))
print(type(1+True))
print(type(1+True+2.0)) #查看变量的类型
print(type(Name) == str)
print(type(Age) == int) #内置断言操作
print(isinstance(Name,str))
print(isinstance(Age,int))
print(isinstance(100,str))
print(isinstance(100,(str,bool,int)))
<class 'str'>
<class 'int'>
<class 'int'>
<class 'float'>
True
True
True
True
False
True
以上代码输出结果戳我可以查看哟~
三.列表（list）
1>.列表概述
一个队列，一个排列整齐的队伍 列表内的个体称作元素，由若干元素组成列表 元素可以是任意对象（数字、字符串、对象、列表等） 列表内元素有顺序，可以使用索引 线性的数据结构 使用[ ] 表示 列表是可变的
请自行查阅资料了解：列表（List）、链表（Linked List）、队列(Queue)、栈(Stack)的差异,我大致总结了下这几种数据结构特点：
列表（List）：在内存空间中是连续地址，查询速度快，修改也快，但不利于频繁新增或删除元素（需要注意的是，队尾新增或者删除元素并不影响性能）。
链表(Linked List)：在内存空间中是不连续地址，查询速度慢，但利于频繁新增或删除元素。
队列(Queue)：其实我们有时候发现他和列表很像，但是不支持像列表那样进行修改，First Input First Output（FIFO）简单说就是指先进先出。就好像我们上班时候进地铁站的时候，拍了很长的队伍，有栏杆围着人群，因此基本上没人插队。
栈(Stack)：类似于我们小时候玩枪的上子弹操作，我们会发现先上子弹却最后才能打出去，即Last In First Out 后进先出法（简称LIFO，即先进后出）。
2>.列表list定义，初始化
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """ list() ----> new entry list list(iterable) ----> new list initalized from iterable's items 列表不能一开始就定义大小 """ list_1 = list() list_2 = [] list_3 = ["","Jason Yin","5.21",[1,3,5,7,9]] list_4 = list(range(10)) print(list_1)
print(list_2)
print(list_3)
print(list_4)
[]
[]
['', 'Jason Yin', '5.21', [1, 3, 5, 7, 9]]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
以上代码输出结果戳我可以查看哟~
3>. 列表索引访问
索引，也叫下标
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界 列表通过索引访问
list[index] ，index就是索引，使用中括号访问，时间复杂度为O(1)，随着列表元素规模的增加，通过索引访问元素的效率并不会降低！
4>.列表查询
index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
随着列表元素规模的增加，性能会逐渐下降，时间复杂度为O(n)。因为它设计到遍历，因此该方法我们在生产环境中应该尽量少用！ count(value)
返回列表中匹配value的次数。该方法相比index来说，属于完全的O(n)，因为index方法匹配到第一个就立即返回索引，可能不会遍历整个列表，但count方法必须遍历整个列表，因此该方法也应该尽量少用！ 时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降。 如何返回列表元素的个数？如何遍历？如何设计高效？
len()
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com list_1 = ["","Jason Yin","","5.21","",[1,3,5,7,9],"","",""] #匹配索引,我们可以给该方法传递三个参数，查看源码就知道第一个参数传递的是要查询的值，第二个参数和第三个参数分别为查询的起始位置和结束位置。
print(list_1.index("Jason Yin"))
print(list_1.index(""))
print(list_1.index("",1))
print(list_1.index("",3))
print(list_1.index("",5,7)) #统计某个值在该列表中出现的次数，该方法的时间复杂度为O(n)
print(list_1.count("")) #以上代码运行结果如下:
1
0
2
4
6
5
代码演示戳我~
5>.如何查看帮助
6>.列表元素修改
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
索引访问修改
list[index] = value
索引不要超界 ''' list_1 = [1,2,3,4,5]
print(list_1) list_1[len(list_1)-1] = 100
print(list_1) #以上代码执行结果如下：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 100]
7>.列表增加，插入元素
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
append(object) -> None
列表尾部追加元素，返回None
返回None就意味着没有新的列表产生，就地修改
时间复杂度是O(1)
''' list_1 = [1,2,3,4,5]
print(list_1)
list_1.append(100)
print(list_1) #以上代码执行结果如下：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 100]
列表的append方法案例展示
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
insert(index, object) -> None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改
时间复杂度是O(n)
索引能超上下界吗？
超越上界，尾部追加
超越下界，头部追加
''' list_1 = [1,2,3,4,5]
print(list_1)
list_1.insert(2,300)
print(list_1) #以上代码执行结果如下：
[1, 2, 3, 4, 5]
[1, 2, 300, 3, 4, 5]
列表的insert方法案例展示（该方法在数据量大的情况下不建议使用，效率极低，我们可以考虑时间复杂度，底层原理分析，该方法插入指定位置后，其后的每个元素都需要往后移动一位。）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
+ -> list
连接操作，将两个列表连接起来
产生新的列表，原列表不变
本质上调用的是__add__()方法 * -> list
重复操作，将本列表元素重复n次，返回新的列表
''' list_1 = [1,2,3,4,5]
list_2 = ["a","b","c","d","e"]
print(list_1)
print(list_2) print(list_1 * 3)
print(list_1 + list_2) #以上代码执行结果如下：
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e']
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e']
“*”和“+”操作案例展示
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
extend(iteratable) -> None
将可迭代对象的元素追加进来，返回None
就地修改
''' list_1 = [1,2,3,4,5]
list_2 = ["a","b","c","d","e"]
print(list_1)
print(list_2)
list_1.extend(list_2)
print(list_1)
print(list_2) #以上代码执行结果如下:
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e']
[1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']
列表的extend方法案例展示
8>.列表删除元素
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
remove(value) -> None
从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改
效率？
''' list_1 = [1,2,3,4,5]
print(list_1)
list_1.remove(3)
print(list_1) #以上代码执行结果如下:
[1, 2, 3, 4, 5]
[1, 2, 4, 5]
列表的remove方法案例展示（原理和insert方法一样，效率也很低！时间复杂度为O(1)）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
pop([index]) -> item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
效率？指定索引的的时间复杂度？不指定索引呢？
''' list_1 = [1,2,3,4,5]
print(list_1) list_1.pop()
print(list_1) list_1.pop(2)
print(list_1) #以上代码执行结果如下:
[1, 2, 3, 4, 5]
[1, 2, 3, 4]
[1, 2, 4]
列表的pop方法（效率相比remove要略高~）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
clear() -> None
清除列表所有元素，剩下一个空列表
''' list_1 = [1,2,3,4,5]
print(list_1) list_1.clear()
print(list_1) #以上代码执行结果如下:
[1, 2, 3, 4, 5]
[]
列表的clear方法案例展示
9>.列表的其他操作
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
reverse() -> None
将列表元素反转，返回None
就地修改
''' list_1 = [1,2,3,4,5]
print(list_1) list_1.reverse()
print(list_1) #以上代码执行结果如下:
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
列表的reverse方法,该方法基本上不用，如果非要将列表的数据倒着打印，我们可以采用反向遍历列表就好，没有必要先反转再遍历，因为反转最少得（n+1）/2次调换，效率很低！不推荐使用~
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie '''
sort(key=None, reverse=False) -> None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序，key不会改变元素本身，只是转换时临时用一下，转换后数值用来比较。
''' list_1 = [100,20,3,40,5]
print(list_1)
list_1.sort()
print(list_1)
list_1.sort(reverse=True)
print(list_1) #以上代码执行结果如下:
[100, 20, 3, 40, 5]
[3, 5, 20, 40, 100]
[100, 40, 20, 5, 3]
列表的sort方法，该方法使用并不频繁，推荐咱们自己写排序算法。
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com list_1 = [1,3,5,7,9]
print(list_1) list_2 = [1,2,3,4,5,6,7,8,9,10]
print(list_2) list_3 = [[1,3,5,7,9],[2,4,6,8,10],[1,2,3],100,300,500]
print(list_1 in list_2)
print(list_1 in list_3)
print(list_2 in list_3) for i in list_3:
print(i) #以上代码执行结果如下:
[1, 3, 5, 7, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
False
True
False
[1, 3, 5, 7, 9]
[2, 4, 6, 8, 10]
[1, 2, 3]
100
300
500
列表的嵌套操作
10>.列表复制
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com list_1 = list(range(4))
list_2 = list(range(4))
print(list_1,id(list_1))
print(list_2,id(list_2)) print(list_1 == list_2) #注意，它比较的是值并不是比较内存地址！
print(list_1 is list_2) list_2[3] = 100
print(list_1)
print(list_2) #以上代码执行结果如下:
[0, 1, 2, 3] 31938568
[0, 1, 2, 3] 31938632
True
False
[0, 1, 2, 3]
[0, 1, 2, 100]
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com list_1 = [1,2,3,[100,200,300],4,5]
list_2 = list_1.copy() print(list_1,id(list_1))
print(list_2,id(list_2))
print(list_2 == list_1)
print(list_2 is list_1) list_2[3][1] = 666666
print(list_1,id(list_1))
print(list_2,id(list_2))
print(list_2 == list_1)
print(list_2 is list_1) #以上代码执行结果如下:
[1, 2, 3, [100, 200, 300], 4, 5] 6887112
[1, 2, 3, [100, 200, 300], 4, 5] 33051592
True
False
[1, 2, 3, [100, 666666, 300], 4, 5] 6887112
[1, 2, 3, [100, 666666, 300], 4, 5] 33051592
True
False
列表的copy（浅拷贝）方法
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com import copy list_1 = [1,2,3,[100,200,300],4,5]
list_2 = copy.deepcopy(list_1)
print(list_1,id(list_1))
print(list_2,id(list_2))
print( list_2 == list_1)
print(list_2 is list_1) list_2[3][2] = 666
print(list_1,id(list_1))
print(list_2,id(list_2))
print( list_2 == list_1)
print(list_2 is list_1) #以上代码执行结果如下:
[1, 2, 3, [100, 200, 300], 4, 5] 43582344
[1, 2, 3, [100, 200, 300], 4, 5] 43583176
True
False
[1, 2, 3, [100, 200, 300], 4, 5] 43582344
[1, 2, 3, [100, 200, 666], 4, 5] 43583176
False
False
使用copy模块的deepcopy（深拷贝）方法拷贝列表案例
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com import random #返回1-5之间的整数
print(random.randint(1,5)) #从非空序列的元素中随机挑选一个元素
print(random.choice(range(10))) #从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
print(random.randrange(1,9,2)) list_1 = [1,2,3,4,5]
print(list_1) #就地打乱列表元素
random.shuffle(list_1)
print(list_1) #从样本空间或总体（序列或者集合类型）中随机取出k个不同的元素，返回一个新的列表
print(random.sample(['a', 'b', 'c', 'd','e','f','g'], 3))
print(random.sample(['a', 'a'], 2))
随机数模块random使用案例案例
11>.列表小练习
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie #打印100内的所有素数
print(1)
print(2)
print(3)
for i in range(3,100,2): #我们知道由于所有的偶数都能被2整除，因此我们这里可以设置步长直接跳过偶数，可以减少循环的次数！
m = i ** 0.5 #我们对当前循环的数字进行开方操作
for j in range(3,i,2): #原理同上
if i % j == 0: #判断当前参数是否能被它之前的数整除，如果不难就直接跳过循环，即把非素数过滤掉！
break
if j>m: #需要注意的是，这算是优化的一种方式吧，直接就过滤了一半的数据
print(i)
break #以上代码执行结果如下:
1
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
求100000内的素数案例
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie import datetime #打印100000内的所有素数
num = 100000
count = 1
ops = 0 start = datetime.datetime.now()
for i in range(3,num,2): #奇数
if i > 10 and i % 5 == 0: #直接过滤掉是5的倍数的数字，可以提高效率
ops += 1
continue
for j in range(3,int(i ** 0.5)+1,2):
ops += 1
if i %j == 0: #合数
break
else:
count += 1 #素数 delta = (datetime.datetime.now() - start).total_seconds() print(count)
print(delta)
print(ops) #以上代码执行结果如下:
9592
0.187501
1338776
求100000内的素数案例优化版本1
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie import datetime #打印100000内的所有素数
num = 100000
ops = 0
primenums = [2] #定义一个素数列表，将素数放在这个列表中。用内存空间换计算时间,即空间换时间 start = datetime.datetime.now()
for i in range(3,num,2): #奇数
flag = False #定义标志位为Flase，默认当前数字并非素数
edeg = int(i ** 0.5)
ops += 1
for j in primenums:
if j > edeg:
flag = True #超过了开方值说明是素数，将标志位设置为True并退出本层循环
break ops += 1
if i % j == 0: #合数
break
if flag:
primenums.append(i) delta = (datetime.datetime.now() - start).total_seconds() print(len(primenums))
print(delta)
print(ops) #以上代码执行结果如下:
9592
0.156248
744436
求100000内的素数案例优化版本2
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #计算杨辉三角前6行
triangle=[[1], [1,1]]
for i in range(2,6):
cur = [1]
pre = triangle[i-1]
for j in range(len(pre)-1):
cur.append(pre[j]+pre[j+1])
cur.append(1)
triangle.append(cur)
print(triangle)
计算杨辉三角前6行（案例展示一）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #计算杨辉三角前6行
triangle=[]
n = 6
for i in range(n):
row = [1]
triangle.append(row)
if i==0:
continue
for j in range(i-1):
row.append(triangle[i-1][ j]+triangle[i-1][ j+1])
row.append(1)
print(triangle)
计算杨辉三角前6行（案例展示二）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #计算杨辉三角前6行
n = 6
newline = [1] # 相当于计算好的第一行
print(newline) for i in range(1, n):
oldline = newline.copy() # 浅拷贝并补0
oldline.append(0) # 尾部补0相当于两端补0
newline.clear() # 使用append，所以要清除 offset = 0
while offset <= i:
newline.append(oldline[offset-1] + oldline[offset])
offset += 1
print(newline)
计算杨辉三角前6行（案例展示三）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #计算杨辉三角前6行
n = 6
newline = [1] # 相当于计算好的第一行
print(newline)
for i in range(1, n):
oldline = newline.copy() # 浅拷贝并补0
oldline.append(0) # 尾部补0相当于两端补0
newline.clear() # 使用append，所以要清除
for j in range(i+1):
newline.append(oldline[ j - 1] + oldline[j])
print(newline)
计算杨辉三角前6行（案例展示四）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #计算杨辉三角前6行
triangle = []
n = 6
for i in range(n):
row = [1] # 开始的1
for k in range(i): # 中间填0，尾部填1
row.append(1) if k == i-1 else row.append(0)
triangle.append(row)
if i == 0:
continue
for j in range(1,i//2+1): # i=2第三行才能进来
val = triangle[i - 1][ j-1] + triangle[i - 1][ j]
row[j] = val
if i != 2*j: # 奇数个数的中点跳过
row[-j-1] = val
print(triangle)
计算杨辉三角前6行（案例展示五）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #计算杨辉三角前6行
triangle = []
n = 6
for i in range(n):
row = [1] * (i+1) # 一次性开辟
triangle.append(row)
for j in range(1,i//2+1): # i=2第三行才能进来
val = triangle[i - 1][ j-1] + triangle[i - 1][ j]
row[j] = val
if i != 2*j: # 奇数个数的中点跳过
row[-j-1] = val
print(triangle)
计算杨辉三角前6行（案例展示六）
四.元组（tuple）
1>.元组（tuple）概述
一个有序的元素组成的集合 使用小括号( ) 表示 元组是不可变对象
2>.元组的定义和初始化
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com #定义元组的几种常见姿势如下所示
t1 = tuple() # 工厂方法
t2 = ()
t3 = tuple(range(1,9,2)) # iteratable
t4 = (2,4,6,3,4,2)
t5 = (1,) # 一个元素元组的定义，注意有个逗号
t6 = (1,)*5
t7 = (1,2,3) * 6 print(t1)
print(t2)
print(t3)
print(t4)
print(t5)
print(t6)
print(t7)
()
()
(1, 3, 5, 7)
(2, 4, 6, 3, 4, 2)
(1,)
(1, 1, 1, 1, 1)
(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
以上代码执行结果如下
3>.元组元素的访问
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
支持索引（下标）
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
元组通过索引访问
tuple[index] ，index就是索引，使用中括号访问
''' name_list = ("Jason Yin","Jennny","Danny","Liming","Dog Cutting",[10,20,30])
print(name_list)
print(name_list,type(name_list))
print(name_list[0])
print(name_list[-2]) name_list[-1][1] = 666
print(name_list)
('Jason Yin', 'Jennny', 'Danny', 'Liming', 'Dog Cutting', [10, 20, 30])
('Jason Yin', 'Jennny', 'Danny', 'Liming', 'Dog Cutting', [10, 20, 30]) <class 'tuple'>
Jason Yin
Dog Cutting
('Jason Yin', 'Jennny', 'Danny', 'Liming', 'Dog Cutting', [10, 666, 30])
以上代码执行结果戳这里~
4>.元组的查询操作（元组是只读的，所以增，改，删方法都没有！）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常ValueError
'''
name_list = ("Jason Yin","Jennny","Danny","Liming","Dog Cutting") print(name_list.index("Jennny"))
print(name_list.index("Jason Yin")) #以上代码输出结果如下：
1
元组的index方法案例展示
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
count(value)
返回列表中匹配value的次数
'''
t1 = (1,3,2,3,4,3,2,3,5,3,2,3,6,3) print(t1.count(3))
print(t1.count(2)) #以上代码输出结果如下：
7
3
元组的count方法案例展示，注意index和count方法的时间复杂度都是O(n)，随着列表数据规模的增大，而效率下降
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
len(tuple)
返回元素的个数
'''
t1 = (1,3,2,3,4,3,2,3,5,3,2,3,6,3) print(len(t1)) #以上代码输出结果如下：
14
元组的len方法案例展示
5>. 命名元组namedtuple使用案例
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com from collections import namedtuple Point = namedtuple('_Point',['x','y']) # Point为返回的类,后面的'x','y'表示定义的属性名称
p = Point(100, 200)
print(p.x)
print(p.y) Student = namedtuple('Student', 'Name Age') #Student为返回的类名,这是咱们自定义的，我们可以直接使用该类名，调用我们自定给定的属性名称
tom = Student('tom', 20)
jerry = Student('jerry', 18) print(tom.Name)
print(tom.Age)
print(jerry.Name)
print(jerry.Age) #以上代码执行结果如下：
100
200
tom
20
jerry
18
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie from collections import namedtuple student = namedtuple("Student",'name,age,address') #注意，student为标识符，可以通过阅读源码，传入参方式会被转换成list jason = student("尹正杰",18,"北京") print(jason.address)
print(jason.age)
print(jason.name)
print(jason) #以上代码执行结构如下:
北京
18
尹正杰
Student(name='尹正杰', age=18, address='北京')
nametuple使用案例
6>.元组练习 （依次接收用户输入的3个数，排序后打印）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com nums = [] for i in range(1,4):
nums.append(int(input("请输入第{}个整数:>>> ".format(i)))) if nums[0] > nums[1]:
if nums[0] > nums[2]:
i3 = nums[0]
if nums[1] > nums[2]:
i2 = nums[1]
i1 = nums[2]
else:
i2 = nums[2]
i1 = nums[1]
else:
i3 = nums[2]
i2 = nums[0]
i1 = nums[1]
else:#0<1
if nums[0] > nums[2]:
i3 = nums[1]
i2 = nums[0]
i1 = nums[2]
else:#0<2
if nums[1] < nums[2]:
i3 = nums[2]
i2 = nums[1]
i1 = nums[0]
else:
i3 = nums[1]
i2 = nums[2]
i1 = nums[0] print(i1,i2,i3)
转换int后，判断大小排序
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com nums = [] out = None for i in range(1,4):
nums.append(int(input("请输入第{}个整数:>>> ".format(i)))) if nums[0] > nums[1]:
if nums[0] > nums[2]:
if nums[1] > nums[2]:
out = [2,1,0]
else:
out = [1,2,0]
else:
out = [1,2,0]
else:
if nums[0] > nums[2]:
out = [2,0,1]
else:#0<2
if nums[1] < nums[2]:
out = [0,1,2]
else:
out = [0,2,1] out.reverse()
for i in out:
print(nums[i],end=",")
针对上一个案例的优化版本
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com nums = [] for i in range(1,4):
nums.append(int(input("请输入第{}个整数:>>> ".format(i)))) #此处不能使用for循环，不能一般迭代该列表，同时删除或者增加该列表
while True:
cur = min(nums)
print(cur)
nums.remove(cur)
if len(nums) == 1:
print(nums[0])
break
使用max和min的实现
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com nums = [] for i in range(1,4):
nums.append(int(input("请输入第{}个整数:>>> ".format(i)))) nums.sort() print(nums)
列表sort实现排序
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com numlist = [
[1,9,8,5,6,7,4,3,2],
] nums = numlist[0] print(nums) length = len(nums) count_swap = 0 count = 0 for i in range(length):
for j in range(length - i - 1):
count += 1
if nums[j] > nums[ j + 1]:
tmp = nums[j]
nums[j] = nums[j+1]
nums[j+1] = tmp
count_swap += 1 print(nums,count_swap,count)
冒泡方法实现排序
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com numlist = [
[1,9,8,5,6,7,4,3,2],
[1,2,3,4,5,6,7,8,9],
[1,2,3,4,5,6,7,8,9]
] nums = numlist[2]
print(nums)
length = len(nums)
count_swap = 0
count = 0 for i in range(length):
flag = False
for j in range(length - i -1):
count += 1
if nums[j] > nums[j+1]:
tmp = nums[j]
nums[j] =nums[j+1]
nums[j+1] = tmp
flag = True
count_swap += 1
if not flag:
break print(nums,count_swap,count)
冒泡方法实现排序（优化）
五.字符串
1>.字符串概述
一个个字符组成的有序的序列，是字符的集合 使用单引号、双引号、三引号引住的字符序列 字符串是不可变对象 Python3起，字符串就是Unicode类型
2>.字符串定义初始化
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s1 = 'string'
s2 = "string2"
s3 = '''this's a "String" '''
s4 = 'hello \n http://www.cnblogs.com/yinzhengjie'
s5 = r"hello \n http://www.cnblogs.com/yinzhengjie"
s6 = 'c:\windows\nt'
s7 = R"c:\windows\nt"
s8 = 'c:\windows\\nt'
sql = """select * from user where name='tom' """ print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)
print(s7)
print(s8)
print(sql)
string
string2
this's a "String"
hello
http://www.cnblogs.com/yinzhengjie
hello \n http://www.cnblogs.com/yinzhengjie
c:\windows
t
c:\windows\nt
c:\windows\nt
select * from user where name='tom'
以上代码输出结果如下
3>.字符串元素访问
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com sql = "select * from user where name='tom'"
print(sql[5])
print(sql[1:5])
print(sql[-1])
字符串支持使用索引访问
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com sql = "select * from user where name='tom'" for item in sql:
print(item)
print(type(item))
有序的字符集合，字符序列
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com sql = "select * from user where name='tom'"
list_1 = list(sql)
print(list_1)
print(len(list_1))
print(sql[0])
print(list_1[0])
print(sql[0] == list_1[0])
可迭代
4>.字符串join连接
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
"string".join(iterable) -> str
将可迭代对象连接起来，使用string作为分隔符
可迭代对象本身元素都是字符串
返回一个新字符串
''' list_1 = ['','','']
print("\"".join(list_1)) # 分隔符是双引号
print(" ".join(list_1))
print("\n".join(list_1))
字符串的join方法
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com a = "I love you !"
b = "Me too." c = a + b
print(c)
使用“+”连接字符串
5>. 字符串分割
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
split系
将字符串按照分隔符分割成若干字符串，并返回列表 split(sep=None, maxsplit=-1) -> list of strings
从左至右
sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit 指定分割的次数，-1 表示遍历整个字符串 ''' s1 = "I'm \ta super student."
print(s1)
print(s1.split()) print(s1.split('s'))
print(s1.split('super'))
print(s1.split('super '))
print(s1.split(' '))
print(s1.split(' ',maxsplit=2))
print(s1.split('\t',maxsplit=2))
print(s1)
split方法分割字符串
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
rsplit(sep=None, maxsplit=-1) -> list of strings
从右向左
sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
maxsplit 指定分割的次数，-1 表示遍历整个字符串
'''
s1 = "I'm \ta super student."
print(s1)
print(s1.rsplit())
print(s1.rsplit('s'))
print(s1.rsplit('super'))
print(s1.rsplit('super '))
print(s1.rsplit(' '))
print(s1.rsplit(' ',maxsplit=2))
print(s1.rsplit('\t',maxsplit=2))
rsplit方法分割字符串
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
splitlines([keepends]) -> list of strings
按照行来切分字符串
keepends 指的是是否保留行分隔符
行分隔符包括\n、\r\n、\r等
''' print('ab c\n\nde fg\rkl\r\n'.splitlines())
print('ab c\n\nde fg\rkl\r\n'.splitlines(True))
s1 = '''I'm a super student.
You're a super teacher.'''
print(s1)
print(s1.splitlines())
print(s1.splitlines(True))
splitlines方法分割字符串
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
partition(sep) -> (head, sep, tail)
从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组
sep 分割字符串，必须指定
'''
s1 = "I'm a super student."
print(s1.partition('s'))
print(s1.partition('stu'))
# print(s1.partition(''))
print(s1.partition('abc'))
partition方法分割字符串
6>.字符串大小写
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s1 = "I'm a super man" print(s1)
print(s1.upper()) #以上代码执行结果如下：
I'm a super man
I'M A SUPER MAN
使用upper()方法将字符串的字母全部转换为大写
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s1 = "I'm a super man" print(s1)
print(s1.lower()) #以上代码执行结果如下：
I'm a super man
i'm a super man
使用lower()方法将字符串字母全部转换为小写
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s1 = "I'm a super man" print(s1)
print(s1.swapcase()) #以上代码执行结果如下：
I'm a super man
i'M A SUPER MAN
使用swapspace()方法将字符串的字母交互大小写（即原来小写的变成大写，原来大写的变成小写）
7>.字符串排版
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s1 = "I'm a super man" print(s1)
print(s1.title()) #以上代码执行结果如下：
I'm a super man
I'M A Super Man
title()标题的每个单词都大写
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s1 = "i'm a super man" print(s1)
print(s1.capitalize()) #以上代码执行结果如下：
i'm a super man
I'm a super man
capitalize()首个单词大写
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
center(width[, fillchar]) -> str
width 打印宽度
fillchar 填充的字符 ''' s1 = "*"*10 print(s1)
print(s1.center(50))
print(s1.center(50,'#')) #以上代码执行结果如下：
**********
**********
####################**********###################
center(width[,fillchar])方法案例展示
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
zfill(width) -> str
width 打印宽度，居右，左边用0填充
''' s1 = "*"*10 print(s1)
print(s1.zfill(50)) #以上代码执行结果如下：
**********
0000000000000000000000000000000000000000**********
zfill(width)案例展示
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
ljust(width[, fillchar]) -> str 左对齐
''' s1 = "*"*10 print(s1)
print(s1.ljust(50,"#")) #以上代码执行结果如下：
**********
**********########################################
ljust(width[, fillchar]) -> str 左对齐
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
rjust(width[, fillchar]) -> str 右对齐
''' s1 = "*"*10 print(s1)
print(s1.rjust(50,"#")) #以上代码执行结果如下：
**********
########################################**********
rjust(width[, fillchar]) -> str 右对齐
8>.字符串修改（注意，字符串本身是不可变的，要明白这里的修改其本质是字符串中找到匹配替换为新子串，返回新字符串）
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
replace(old, new[, count]) -> str
字符串中找到匹配替换为新子串，返回新字符串
count表示替换几次，不指定就是全部替换
""" s1 = "www.yinzhengjie.org.cn" print(s1)
print(s1.replace('w','p'))
print(s1.replace('w','p',2))
print(s1.replace('w','p',3))
print(s1.replace('ww','p'))
print(s1.replace('ww','p',2))
print(s1.replace('www','python',2)) #以上代码执行结果如下：
www.yinzhengjie.org.cn
ppp.yinzhengjie.org.cn
ppw.yinzhengjie.org.cn
ppp.yinzhengjie.org.cn
pw.yinzhengjie.org.cn
pw.yinzhengjie.org.cn
python.yinzhengjie.org.cn
replace(old, new[, count]) -> str 字符串中找到匹配替换为新子串，返回新字符串 count表示替换几次，不指定就是全部替换
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
strip([chars]) -> str
从字符串两端去除指定的字符集chars中的所有字符
如果chars没有指定，去除两端的空白字符
""" s1 = "\r \n \t Hello Python \n \t"
s2 = " I am very very very sorry " print(s1)
print(s1.strip())
print(s2)
print(s2.strip("r"))
print(s2.strip("r "))
print(s2.strip("r y"))
print(s2.strip("r yIamso"))
strip([chars]) -> str 从字符串两端去除指定的字符集chars中的所有字符 如果chars没有指定，去除两端的空白字符
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
rstrip([chars]) -> str
从字符串右边开始去除指定的字符集chars中的所有字符 """ s1 = " I am very very very sorry " print(s1)
print(s1.rstrip("r yIamso")) #以上代码执行结果如下:
I am very very very sorry
I am very very ve
rstrip([chars]) -> str 从字符串右边开始去除指定的字符集chars中的所有字符
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
lstrip([chars]) -> str
从字符串左边开始去除指定的字符集chars中的所有字符 """ s1 = " I am very very very sorry " print(s1)
print(s1.lstrip("r yIamso"))
print(s1.rstrip("r yIamso")) #以上代码执行结果如下:
I am very very very sorry
very very very sorry
I am very very ve
lstrip([chars]) -> str 从字符串左边开始去除指定的字符集chars中的所有字符
9>.字符串查找
时间复杂度：
find,index,count方法都是O(n)。
随着列表的数据规模的增大，而效率下降。 len(string):
返回字符串的长度，即字符的个数。
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
find(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1
""" s1 = "I am very very very sorry" print(s1)
print(s1.find("very"))
print(s1.find("very",5))
print(s1.find("very",6,13)) #以上代码执行结果如下:
I am very very very sorry
5
5
-1
find(sub[, start[, end]]) -> int 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
rfind(sub[, start[, end]]) -> int
在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1
""" s1 = "I am very very very sorry" print(s1)
print(s1.rfind("very"))
print(s1.rfind("very",10,15))
print(s1.rfind("very",-10,-1)) #以上代码执行结果如下:
I am very very very sorry
15
10
15
rfind(sub[, start[, end]]) -> int 在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
index(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
""" s1 = "I am very very very sorry" print(s1)
print(s1.index("very"))
print(s1.index("very",5))
print(s1.index('very',6,20)) #以上代码执行结果如下:
I am very very very sorry
5
5
10
index(sub[, start[, end]]) -> int 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
rindex(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
""" s1 = "I am very very very sorry" print(s1)
print(s1.rindex('very',10))
print(s1.rindex('very',10,15))
print(s1.rindex('very',-10,-1)) #以上代码执行结果如下:
I am very very very sorry
15
10
15
rindex(sub[, start[, end]]) -> int 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
len(string)
返回字符串的长度，即字符的个数
""" s1 = "I am very very very sorry" print(s1)
print(len(s1)) #以上代码执行结果如下:
I am very very very sorry
25
len(string) 返回字符串的长度，即字符的个数
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
时间复杂度
index和count方法都是O(n)
随着列表数据规模的增大，而效率下降 count(sub[, start[, end]]) -> int
在指定的区间[start, end)，从左至右，统计子串sub出现的次数
""" s1 = "I am very very very sorry" print(s1)
print(s1.count('very',5))
print(s1.count('very',10,14)) #以上代码执行结果如下:
I am very very very sorry
3
1
count(sub[, start[, end]]) -> int 在指定的区间[start, end)，从左至右，统计子串sub出现的次数
10>.字符串判断
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
startswith(prefix[, start[, end]]) -> bool
在指定的区间[start, end)，字符串是否是prefix开头
""" s1 = "I am very very very sorry" print(s1)
print(s1.startswith('very'))
print(s1.startswith('very',5))
print(s1.startswith('very',5,9)) #以上代码执行结果如下:
I am very very very sorry
False
True
True
startswith(prefix[, start[, end]]) -> bool 在指定的区间[start, end)，字符串是否是prefix开头
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
endswith(suffix[, start[, end]]) -> bool
在指定的区间[start, end)，字符串是否是suffix结尾
""" s1 = "I am very very very sorry" print(s1)
print(s1.endswith('very',5,9))
print(s1.endswith('sorry',5))
print(s1.endswith('sorry',5,-1))
print(s1.endswith('sorry',5,100)) #以上代码执行结果如下:
I am very very very sorry
True
True
False
True
endswith(suffix[, start[, end]]) -> bool 在指定的区间[start, end)，字符串是否是suffix结尾
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
isalnum() -> bool 是否是字母和数字组成
""" s1 = "I am very very very sorry"
s2 = 'ABC123' print(s1)
print(s1.isalnum())
print(s2)
print(s2.isalnum()) #以上代码执行结果如下:
I am very very very sorry
False
ABC123
True
isalnum() -> bool 是否是字母和数字组成
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
isalpha() 是否是字母
""" s1 = "I am very very very sorry"
s2 = 'ABCDE' print(s1)
print(s1.isalpha())
print(s2)
print(s2.isalpha()) #以上代码执行结果如下:
I am very very very sorry
False
ABCDE
True
isalpha() 是否是字母
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
isdecimal() 是否只包含十进制数字
""" s1 = '10EF'
s2 = ''
print(s1.isdecimal())
print(s2.isdecimal()) #以上代码执行结果如下:
False
True
isdecimal() 是否只包含十进制数字
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
isdigit() 是否全部数字(0~9)
""" s1 = '10EF'
s2 = ''
print(s1.isdigit())
print(s2.isdigit()) #以上代码执行结果如下:
False
True
isdigit() 是否全部数字(0~9)
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
""" s1 = '10EF'
s2 = '_123456'
s3 = '_len'
s4 = 'Abc_123'
s5 = 'Abc#123' print(s1.isidentifier())
print(s2.isidentifier())
print(s3.isidentifier())
print(s4.isidentifier())
print(s5.isidentifier()) #以上代码执行结果如下:
False
True
True
True
False
isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
islower() 是否都是小写
""" s1 = 'Abc'
s2 = 'abc'
print(s1.islower())
print(s2.islower()) #以上代码执行结果如下:
False
True
islower() 是否都是小写
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
isupper() 是否全部大写
""" s1 = 'Abc'
s2 = 'ABC' print(s1.isupper())
print(s2.isupper()) #以上代码执行结果如下:
False
True
isupper() 是否全部大写
isspace() 是否只包含空白字符
11>.字符串格式化
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
join拼接只能使用分隔符，且要求被拼接的是可迭代对象
+ 拼接字符串还算方便，但是非字符串需要先转换为字符串才能拼接 在2.5版本之前，只能使用printf style风格的print输出
printf-style formatting，来自于C语言的printf函数
格式要求
占位符：使用%和格式字符组成，例如%s、%d等
s调用str()，r会调用repr()。所有对象都可以被这两个转换。
占位符中还可以插入修饰字符，例如%03d表示打印3个位置，不够前面补零
format % values，格式字符串和被格式的值之间使用%分隔
values只能是一个对象，或是一个和格式字符串占位符数目相等的元组，或一个字典
""" print("I am %05d" % (18,))
print('I like %s.' % 'Python')
print('%3.2f%% , 0x%x, 0X%02X' % (89.7654, 10, 15))
print("I am %-5d" % (20,)) #以上代码执行结果如下:
I am 00018
I like Python.
89.77% , 0xa, 0X0F
I am 20
printf-style formatting 举例-C语言风格，Python源码中有很多这样的语法
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie """
format函数格式字符串语法——Python鼓励使用
"{} {xxx}".format(*args, **kwargs) -> str
args是位置参数，是一个元组
kwargs是关键字参数，是一个字典
花括号表示占位符
{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值
{xxx}表示在关键字参数中搜索名称一致的
{{}} 表示打印花括号
""" #位置参数，，这就是按照位置顺序用位置参数替换前面的格式字符串的占位符中
print("{}:{}".format('192.168.1.100',8888)) #关键字参数或命名参数,，位置参数按照序号匹配，关键字参数按照名词匹配
print("{server} {1}:{0}".format(8888, '192.168.1.100', server='Web Server Info : ')) #访问元素
"{0[0]}.{0[1]}".format(('magedu','com')) #对象属性访问
from collections import namedtuple
Point = namedtuple('Point','x y')
p = Point(4,5)
print("{{{0.x},{0.y}}}".format(p)) #对齐
print('{0}*{1}={2:<2}'.format(3,2,2*3))
print('{0}*{1}={2:<02}'.format(3,2,2*3))
print('{0}*{1}={2:>02}'.format(3,2,2*3))
print('{:^30}'.format('centered'))
print('{:*^30}'.format('centered')) #进制
print("int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42))
print("int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42))
octets = [192, 168, 0, 1]
print('{:02X}{:02X}{:02X}{:02X}'.format(*octets)) #浮点数
print("{}".format(3**0.5))
print("{:f}".format(3**0.5)) #精确度默认6
print("{:10f}".format(3**0.5)) #右对齐，宽度10
print("{:2}".format(102.123)) #宽度为2的数字
print("{:.2}".format(3**0.5)) #2个有效数字
print("{:.2f}".format(3**0.5)) #保留小数点后2位
print("{:3.2f}".format(3**0.5)) #宽度为3，保留小数点后2位
print("{:20.3f}".format(0.2745)) #宽度为20，保留小数点后3位,四舍五入
print("{:3.3%}".format(1/3)) #宽度位3，保留3位小数，注意宽度可以被撑破，我们发现宽度为3并没有生效，因为光小数点后面保留3为就已经打破了宽度为3的限定，说明宽度限定只是一个软限定，而且数字使用%来显示的哟~ #以上代码输出结果如下:
192.168.1.100:8888
Web Server Info : 192.168.1.100:8888
{4,5}
3*2=6
3*2=60
3*2=06
centered
***********centered***********
int: 42; hex: 2a; oct: 52; bin: 101010
int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010
C0A80001
1.7320508075688772
1.732051
1.732051
102.123
1.7
1.73
1.73
0.275
33.333%
format函数格式字符串语法——Python鼓励使用
12>.字符串练习
用户输入一个数字：
判断是几位数
打印每一位数字及其重复的次数。打印顺序个，十，百，千，万...位打印 输入5个数字，打印每个数字的位数，将三个数字排序打印，要求升序打印。
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com num = " " while True:
num = input("请输入一个整数:>>>").strip().lstrip("")
if num.isdigit():
break
else:
print("输入错误，请输入一个[0-9]的整数.") count = [0] * 10 for i in range(10):
count[i] = num.count(str(i)) for j in range(10):
if count[j] :
print("数字 {} 出现了 {} 次".format(j,count[j])) list_1 = list(num)
list_1.reverse() print(list_1)
参考案例
六.bytes和bytearray
1>.bytes概述
Python3引入两个新类型
bytes
不可变字节序列
bytearray
字节数组
可变 字符串与bytes
字符串是字符组成的有序序列，字符可以使用编码来理解
bytes是字节组成的有序的不可变序列
bytearray是字节组成的有序的可变序列 编码与解码
字符串按照不同的字符集编码encode返回字节序列bytes
encode(encoding='utf-8', errors='strict') -> bytes
字节序列按照不同的字符集解码decode返回字符串
bytes.decode(encoding="utf-8", errors="strict") -> str
bytearray.decode(encoding="utf-8", errors="strict") -> str ASCII（American StandardCode for InformationInterchange，美国信息交换标准代码）是基于拉丁字母的一套单字节编码系统. 熟记以下结果ASCII对应的字符：
\t,
\r,
\n,
0-9,
A-Z,
a-z,
2>.bytes定义
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
定义
bytes() 空bytes
bytes(int) 指定字节的bytes，被0填充
bytes(iterable_of_ints) -> bytes [0,255]的int组成的可迭代对象
bytes(string, encoding[, errors]) -> bytes 等价于string.encode()
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制出一个新的不可变的bytes对象
使用b前缀定义：
案例一：只允许基本ASCII使用字符形式b'abc9'
案例二：使用16进制表示b"\x41\x61"
''' #空bytes
b1 = bytes() #指定字节的bytes，被0填充
b2 = bytes(3) #bytes [0,255]的int组成的可迭代对象
b3 = bytes([1,3,5,7,9]) #bytes 等价于string.encode()
b4 = bytes("ABC","utf8")
b5 = "ABC".encode()
b6 = b4.decode()
b7 = b5.decode() #从一个字节序列或者buffer复制出一个新的不可变的bytes对象
a = b'abc'
b = bytes(a)
print(b1)
print(b2)
print(b3)
print(b4)
print(b5)
print(b6)
print(b7)
print(a)
print(b)
print(id(a) == id(b))
print(id(a) is id(b)) #以上代码执行结果如下:
b''
b'\x00\x00\x00'
b'\x01\x03\x05\x07\t'
b'ABC'
b'ABC'
ABC
ABC
b'abc'
b'abc'
True
False
3>.bytes操作
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
和str类型类似，都是不可变类型，所以方法很多都一样。只不过bytes的方法，输入是bytes，输出是bytes
""" print(b'abcdef'.replace(b'f',b'k')) print(b'abc'.find(b'b')) #以上代码执行结果如下:
b'abcdek'
1
和str类型类似，都是不可变类型，所以方法很多都一样。只不过bytes的方法，输入是bytes，输出是bytes
类方法bytes.fromhex(string),类似于Java的static方法
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
hex()
返回16进制表示的字符串
""" print('abc'.encode().hex()) #以上代码执行结果如下:
616263
hex() 返回16进制表示的字符串
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com """
索引
b'abcdef'[2] 返回该字节对应的数，int类型
""" print(b'abcdef'[2] ) #以上代码执行结果如下:
99
索引 b'abcdef'[2] 返回该字节对应的数，int类型
4>.bytearray定义
bytearray() 空bytearray bytearray(int) 指定字节的bytearray，被0填充 bytearray(iterable_of_ints) -> bytearray [0,255]的int组成的可迭代对象 bytearray(string, encoding[, errors]) -> bytearray 近似string.encode()，不过返回可变对象 bytearray(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的可变的bytearray对象 注意，b前缀定义的类型是bytes类型
5>.bytearray操作
和bytes类型的方法相同
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com b = bytearray()
print(b) #append(int) 尾部追加一个元素
b.append(97)
b.append(99)
print(b) #insert(index, int) 在指定索引位置插入元素
b.insert(1,98)
print(b) #extend(iterable_of_ints) 将一个可迭代的整数集合追加到当前bytearray
b.extend([65,66,67])
print(b) #pop(index=-1) 从指定索引上移除元素，默认从尾部移除
b.remove(66)
print(b) #remove(value) 找到第一个value移除，找不到抛ValueError异常
b.pop()
print(b) #reverse() 翻转bytearray，就地修改
b.reverse()
print(b) #clear() 清空bytearray
b.clear()
print(b) #以上代码执行结果如下：
bytearray(b'')
bytearray(b'ac')
bytearray(b'abc')
bytearray(b'abcABC')
bytearray(b'abcAC')
bytearray(b'abcA')
bytearray(b'Acba')
bytearray(b'')
6>.字节序
小白一开始听到字节序这个名词，估计会有点蒙蔽，其实顾名思义就是字节的顺序嘛。计算机硬件有两种储存数据的方式：大端字节序（big endian）和小端字节序（little endian）。 ok，我们先不解释大端模式和小端模式，我先问你一个问题，"我喜欢你"这4个字大家都知道啥意思吧？在古代的时候他们会这样写："你欢喜我"。这就是我们写字的顺序。其实在现代也有很多复古的酒店，参观还保持这种风格。说白了就是读取的顺序不同。 举例来说，数值0x2211使用两个字节储存：高位字节是0x22，低位字节是0x11。
大端字节序：高位字节在前，低位字节在后，这是人类读写数值的方法。
小端字节序：低位字节在前，高位字节在后，即以0x1122形式储存。 关于字节序模式的使用，在各个平台可能不太一样，如下所示：
Intel x86 CPU使用小端模式
网络传输更多使用大端模式
Windows，Linux使用小端模式
Mac OS使用大端模式
Java虚拟机是大端模式
7>.int和bytes
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie #将一个字节数组表示成整数
i = int.from_bytes(b"abc","big")
print(i,hex(i)) #将一个整数表达成一个指定长度的字节数组
print(i.to_bytes(3,"big")) b = bytearray()
b.append(97)
b.extend(range(98,100))
print(b) #以上代码执行结果如下:
6382179 0x616263
b'abc'
bytearray(b'abc')
七.切片
1>.线性结构
线性结构
可迭代for ... in
len()可以获取长度
通过下标可以访问
可以切片
学过的线性结构
列表、元组、字符串、bytes、bytearray
2>.切片概要
切片
通过索引区间访问线性结构的一段数据
sequence[start:stop] 表示返回[start, stop)区间的子序列
支持负索引
start为0，可以省略
stop为末尾，可以省略
超过上界（右边界），就取到末尾；超过下界（左边界），取到开头
start一定要在stop的左边
[:] 表示从头至尾，全部元素被取出，等效于copy()方法
3>.切片举例
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com s = "www.yinzhengjie.org.cn" print(s[4:10])
print(s[:10])
print(s[4:])
print(s[:])
print(s[:-1])
print(s[4:-4])
print(s[4:-50])
print(s[-40:10]) print(bytearray(b'www.yinzhengjie.org.cn')[-4:10]) print(tuple("www.yinzhengjie.org.cn")[-10:10]) print(list("www.yinzhengjie.org.cn")[-10:-4]) #以上代码执行结果如下:
yinzhe
www.yinzhe
yinzhengjie.org.cn
www.yinzhengjie.org.cn
www.yinzhengjie.org.c
yinzhengjie.or www.yinzhe
bytearray(b'')
()
['j', 'i', 'e', '.', 'o', 'r']
#！/usr/bin/env python
#_*_coding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
#EMAIL:y1053419035@qq.com '''
步长切片
[start:stop:step]
step为步长，可以正、负整数，默认是1
step要和start:stop同向，否则返回空序列
''' print("www.yinzhengjie.org.cn"[4:10:2]) print(list("www.yinzhengjie.org.cn"[4:10:-2])) print(tuple("www.yinzhengjie.org.cn")[-10:-4:2]) print(b"www.yinzhengjie.org.cn"[-4:-10:2]) print(bytearray(b"www.yinzhengjie.org.cn")[-4:-10:-2]) #以上代码执行结果如下:
ynh
[]
('j', 'e', 'o')
b''
bytearray(b'goe')
步长切片 [start:stop:step] step为步长，可以正、负整数，默认是1 step要和start:stop同向，否则返回空序列