第2天，Python基础

作者: CaiGuangyin | 来源:发表于2017-05-12 18:48 被阅读24次

[toc]

一、进制

二进制：逢2进1，0 1 （只有0和1两个数）
八进制：逢8进1，0 1 2 3 4 5 6 7 （8个数字）
十进制：逢10进1，0 1 2 3 4 5 6 7 8 9 （10个数字）
十六进制：逢16进1，0 1 2 3 4 5 6 7 8 9 A B C D E F （16个数字，A=10，B=11，C=12，D=13，E=14，F=15）

进制对应：

|十六进制|0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F|10|
|:-:|
|十进制|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|
|八进制|0|1|2|3|4|5|6|7|10|11|12|13|14|15|16|17|20|
|二进制|0|1|10|11|100|101|110|111|1000|1001|1010|1011|1100|1101|1110|1111|10000|

进制转换：

在线进制转换

十进制转二进制：除2取余，不够除，取0余1，以53为例，如下图：

十进制转二进制
十进制转八进制：

十进制转八进制
十进制转十六进制：

Paste_Image.png
二进制转十进制：装水桶法：

二进制转十进制

十六进制转二进制：

十六进制转二进制

二、数据类型

1、str 字符串

字符串是不可变的数据类型

1.capitalize

字符串首字母大写

name = 'alex'
v = name.capitalize()
print(name)
print(v)

2. casefold

将所有大写变小写（也可以将欧洲的一些特殊大写字母变为小写）

name = 'AleX'
v = name.casefold()  # 注意，有些python版本可能没有这个方法，我的python3.5.2就没有，不必太在意
print(name)
print(v)

3. swapcase

将大写转小写，小写转大写

name = 'AleX'
a = name.swapcase()
print(name)
print(a)

4. lower

将所有大小变小写

name = 'AleX'
v = name.lower()
print(v)

5. upper

将所有小写变大写

name = 'alex'
v = name.upper()  
print(v)

6. center

文本居中，两边用指定字符填充

# 参数1: 表示总长度
# 参数2：空白处填充的字符（长度为1）
name = 'alex'
v = name.center(20,'#')
print(v)
输出：
########alex########

7. count

表示传入字符或子字符串在大字符串中出现的次数

# 参数1： 要查找的值（子序列）
# 参数2： 起始位置（索引）
# 参数3： 结束位置（索引）
name = "alexasdfdsafsdfasdfaaaaaaaa"
v = name.count('a')
print(v)
v1 = name.count('df')
print(v1)
输出：
12
3

name = "alexasdfdsafsdfasdfaaaaaaaa"
v = name.count('df',12)
print(v)
v = name.count('df',0,15)
print(v)
输出：
2
2

8. startswith

是否以XXX开头，返回True 或 False

name = 'alex'
v2 = name.startswith('al')
print(v2)

9. endswith

是否以xx结尾

name = 'alex'
v1 = name.endswith('ex')
print(v1)

10. expandtabs

找到制表符\t,进行替换（包含前面的值）

name = "al\te\tx\nalex\tuu\tkkk"
v = name.expandtabs(20)
print(v)
输出：
al                  e                   x
alex                uu                  kkk

11. find

找到指定子序列的索引位置：不存在返回-1

name = 'alex'
v = name.find('e')
print(v)

12. index

找到指定子序列的索引位置：不存在报错

name = 'alex'
v = name.index('o')
print(v)

13. format

字符串格式化

方法1.

tpl = "我是:{0};年龄:{1};性别:{2}"  #位置必须一一对应
v = tpl.format("李杰",19,'都行')
print(v)
输出：
我是:李杰;年龄:19;性别:都行

方法2.

tpl = "我是:{name};年龄:{age};性别:{gender}"
v = tpl.format(name='李杰',age=19,gender='随意')
print(v)

14. format_map

字符串格式化，以字典的形式赋值

tpl = "我是:{name};年龄:{age};性别:{gender}"
v = tpl.format_map({'name':"李杰",'age':19,'gender':'中'})
print(v)
输出：
我是:李杰;年龄:19;性别:中

15. isalnum

是否是数字、汉字、字母，如果包含符号返回False

name  = 'alex8汉子'
v = name.isalnum() # 字,数字
print(v)    # True

16. isalpha

是否是纯字母

name  = 'alex8汉子'
v2 = name.isalpha()#
print(v2)   # False

17. isdecimal 、isdigit 、isnumeric

判断是否是数字

num = '②'
v1 = num.isdecimal() # 可识别 '123'
v2 = num.isdigit()   # 可识别 '123'，'②'
v3 = num.isnumeric() # 可识别 '123'，'二'，'②'
print(v1,v2,v3)

18. isidentifier

是否是符号规范的标示符（变量名）

n = 'name'
v = n.isidentifier()
print(v)

19. islower、isupper

是否全部是小写或大写

name = "ALEX"
v = name.islower()    # 是否全是小写
print(v)
v = name.isupper()    # 是否全是大写  
print(v)

20. isprintable

判断是否包含不可打印的字符（如: “\n”、"\t"等），包含返回False，不包含返回True

name = "钓鱼要钓刀鱼，\n刀鱼要到岛上钓"
v = name.isprintable()
print(v)

21. isspace

是否全部是空格

name = ' '
v = name.isspace()
print(v)

22. join

元素拼接

name = 'alex'
v = "_".join(name) # 内部循环每个元素
print(v)
输出：
a_l_e_x

name_list = ['海峰','杠娘','李杰','李泉']
v = "搞".join(name_list)
print(v)
输出：
海峰搞杠娘搞李杰搞李泉

23. ljust 、rjust

左右填充

name = 'alex'
v = name.rjust(20,' ')
v1 = name.ljust(20,' ')
print(v)
print(v1)
输出：
                alex
alex

24. maketrans 、translate

对应关系 + 翻译

m = str.maketrans('aeiou','12345') # 对应关系
name = "aaeeiioouu"
v = name.translate(m)       # 依照对应关系翻译
print(v)
输出：
1122334455

25. partition

分割，保留被当作分割符的元素。split 方法不会保留被当作分割符的元素。

content = "李泉爱刘康爱刘一"
v = content.partition('爱') # partition
print(v)
v1 = content.split('爱')
print(v1)
输出：
('李泉', '爱', '刘康爱刘一')
['李泉', '刘康', '刘一']

partition 分割后的值是元组类型，并且只能以第一个分割符分割
split 分割后的值是列表类型

26. replace (替换)

content = "李泉SB刘康SB刘浩SB刘一"
v = content.replace('SB','Love')
print(v)
v = content.replace('SB','Love',1)  # 只替换第1个
print(v)
输出：
李泉Love刘康Love刘浩Love刘一
李泉Love刘康SB刘浩SB刘一

27. zfill

填充0，包含已存在字符

name = "alex"
v = name.zfill(20)
print(v)
输出：
0000000000000000alex

28. 额外功能：

# name = "alex"
# name[0]
# name[0:3]
# name[0:3:2]
# len(name)
# for循环，每个元素是字符

2. int 整数

1. bit_length

当前整数用二进制表示时占用几个二进制位

age = 4     # 二进制为100
print(age.bit_length())
输出：
3

2. to_bytes

获取当前数据的字节表示

age = 15
v = age.to_bytes(10,byteorder='big')
v1 = age.to_bytes(10,byteorder='little')
print(v)
print(v1)
输出：
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f'
b'\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00'

3. 布尔值（bool）

布尔值只有True和False

* 转换
* 
    * 数字转布尔值，只有0是False，其他都为True；
    * 字符串转布尔值，只有”“(空)是False，其他都为True；

4. list 列表

1) append (追加)

user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
user_list.append('刘铭')
print(user_list)

2) clear (清空)

user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
user_list.clear()
print(user_list)

3) copy (拷贝(浅拷贝))

user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
v = user_list.copy()
print(v)
print(user_list)

4) count (计数)

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.count('李泉')
print(v)
输出：
2

5) extend (扩展原列表)

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] 
user_list.extend(['郭少龙','郭少霞'])
print(user_list)
输出：
['李泉', '刘一', '李泉', '刘康', '豆豆', '小龙', '郭少龙', '郭少霞']

6) index

查找元素索引，没有会报错

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] 
v = user_list.index('刘康')
print(v)

7) pop

通过索引删除元素，并且返回被删除的元素

ser_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.pop(1)
print(v)
print(user_list)
输出：
刘一
['李泉', '李泉', '刘康', '豆豆', '小龙']

8) remove

通过指定元素来删除元素

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.remove('刘一')
print(user_list)

9) reverse (翻转)

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.reverse()
print(user_list)
输出：
['小龙', '豆豆', '刘康', '李泉', '刘一', '李泉']

10) sort (排序)

nums = [11,22,3,3,9,88]
print(nums)
# 排序，从小到大
nums.sort()
print(nums)
# 从大到小
nums.sort(reverse=True)
print(nums)

11) 额外操作

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙']
user_list[0]      # 通过索引获取值
user_list[1:5:2]    # 切片，步长
del user_list[3]    # 通过索引删除元素
for i in user_list: #循环列表
     print(i)
user_list[1] = '姜日天'    #通过索引修改元素值

5. 元组

元组可以看作是只读列表，元组内的元素不可修改

定义元组：
user_tuple = ('alex','eric','seven','alex')

1) count (计数)

user_tuple = ('alex','eric','seven','alex')
v = user_tuple.count('alex')
print(v)

2) index

获取值的第一个索引位置

user_tuple = ('alex','eric','seven','alex')
v = user_tuple.index('alex')
print(v)

3) 额外操作

user_tuple = ('alex','eric','seven','alex')
for i in user_tuple:   # 遍历元组中的元素 
    print(i)

v = user_tuple[0]  # 获取元组内的元素

v = user_tuple[0:2]     # 切片
print(v)

4) 元组嵌套列表

user_tuple = ('alex','eric','seven',['陈涛','刘浩','赵芬芬'],'alex')
#user_tuple[0] = 123   #x错误
#user_tuple[3] = [11,22,33] #x错误，不可以修改元组中的元素本身
user_tuple[3][1] = '刘一'     # 可以修改元组中嵌套的列表中的元素
print(user_tuple)

总结：元组中元素是可变的数据类型时，那么可以修改此元素内的子元素，但是不可以替换此元素；元组中的元素是不可变的数据类型时，则不可以修改。

5) 元组注意事项

定义元组时，在元组的最后一个元素后面尽量跟一个逗号
因为当元组中只有一个元素时，如果没在元素后边加逗号，则会将这个元组当成一个字符串，示例代码：

li = ('alex')
print(li)
print(type(li))
输出：
alex
<class 'str'>

加上逗号后：

li = ('alex',)
print(li)
print(type(li))
输出：
('alex',)
<class 'tuple'>

6. dict 字典

字典也是可变的数据类型
字典的特性：

dict是无序的
key必须是唯一的,so 天生去重

1) clear (清空)

dic = {'k1':'v1','k2':'v2'}
dic.clear()
print(dic)

2) copy (浅拷贝)

dic = {'k1':'v1','k2':'v2'}
v = dic.copy()
print(v)

3) get

根据key获取指定的value；不存在不报错

dic = {'k1':'v1','k2':'v2'}
v = dic.get('k1111',111)  # 不存在会返回给定值111，没有指定值会返回None 
print(v) 
v = dic['k1111']  # 不存在会报错
print(v)

4) pop

删除键并获取对应的value值

dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k1')
print(dic)
print(v)
输出：
{'k2': 'v2'}
v1

5) popitem

随机删除键值对，并获取到删除的键值

dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()
print(dic)
print(v)
输出：
{'k2': 'v2'}
('k1', 'v1')

另一种玩法：

dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()   # ('k2', 'v2')
print(dic)
print(v[0],v[1])
输出：
{'k2': 'v2'}
k1 v1

另一种玩法：

dic = {'k1':'v1','k2':'v2'}
k,v = dic.popitem() # ('k2', 'v2')
print(dic)
print(k,v)
输出：
{'k2': 'v2'}
k1 v1

6) setdefault

增加，如果存在则不做操作

dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k3','v3')  # 将第1个参数设为key,第2个参数设为value
print(dic)
dic.setdefault('k1','1111111')   # k1是存在的，看输出的结果是否有变化
print(dic)
输出：
{'k2': 'v2', 'k3': 'v3', 'k1': 'v1'}
{'k2': 'v2', 'k3': 'v3', 'k1': 'v1'}

7) update

批量增加或修改；无，则增加；有，则修改

dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k1':'v24'})
print(dic)
输出：
{'k2': 'v2', 'k3': 'v3', 'k1': 'v24'}

8) fromkeys

通过一个列表生成默认dict,有个没办法解释的坑，少用这个吧

dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)
dic = dict.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 'abc'
dic['k2'] = 'ABC'
print(dic)
输出：
{'k2': 123, 'k3': 123, 'k1': 123}
{'k2': 'ABC', 'k3': 123, 'k1': 'abc'}

注意这个坑：

dic = dict.fromkeys(['k1','k2','k3'],[1,])
dic['k1'].append(222)
print(dic)
输出：
{'k2': [1, 222], 'k3': [1, 222], 'k1': [1, 222]}

注意：以上代码，本来我只想对k1的value进行追加一个值222，但是从打印的结果看，k1、k2、k3的value均被追加了这个值。

9) 额外操作

字典可以嵌套
字典key: 必须是不可变类型

例：可以这样定义一个字典，各种嵌套

dic = {
    'k1': 'v1',
    'k2': [1,2,3,],
    (1,2): 'lllll',
    1: 'fffffffff',
    111: 'asdf',
}
print(dic)
输出：
{(1, 2): 'lllll', 'k2': [1, 2, 3], 111: 'asdf', 1: 'fffffffff', 'k1': 'v1'}

# 删除key
dic = {'k1':'v1'}
del dic['k1']

7. set 集合

集合，是不可重复的列表；可变的数据类型

集合创建

# 两种方法：
a = {1,2,3,4,5}
b = set([4,5,6,7,8])

集合运算

名称	英文方法	运算符号	功能	释义
交集	a.intersection(b)	a & b	a与b 的交集	a与b都存在的值
并集	a.union(b)	a (管道符) b	a与b的并集	将a与b融合在一起，去除重复的值
差集	a.difference(b)	a - b (减号)	差集，in a but not in b	a中存在的，且b中不存在的
对称差集	a.symmetric_difference(b)	a ^ b	a与b 的对称差集	将a和b整合,去除a与b都有的值
子集	a.issubset(A)	无	判断a 是A 的子集	判断a是否存在于A中
父集	print(A.issuperset(a))	无	判断A 是a 的父集	判断A是否包含a

总结：对称差集等于并集减交集

1. isdisjoint

判断两个集合是否存在交集

a.isdisjoint(c)  # a与c 存在交集返回False，不存在交集返回True

2. difference_update

获取s1 与s2的差集，并重新赋值给s1

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
s1.difference_update(s2)
print(s1)
输出：
{'李泉11', '李泉'}

3. discard（丢弃）

丢弃集合中指定的元素，如果集合中没有此元素，则不做操作

s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.discard('alex')
print(s1)

4. remove (移除)

有，则移除；没有，则报错

s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.remove("alex")
print(s1)

5. update

更新集合，已有的元素，不变，没有，则添加

s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.update({'alex','123123','fff'})
print(s1)
输出：
{'alex', 'tony', '123123', 'eric', 'fff', '李泉', '李泉11'}

6. pop （随机删除）

随机删除并返回被删除的集合元素,如果集合为空，则报错。

s1 = {"alex",'eric','tony','李泉','李泉11'}
v = s1.pop()
print(s1)
print(v)
输出：
{'李泉11', 'alex', 'tony', '李泉'}
eric

7. add (添加)

无，则添加；有，则不做操作

s1 = {"alex",'eric','tony'}
s1.add('seven')
print(s1)
输出：
{'seven', 'tony', 'alex', 'eric'}

8. symmetric_difference_update

取对称差集重新赋值给s1

s1 = {1,2,3,4}
s2 = {3,4,5,6}
s1.symmetric_difference_update(s2)
print(s1)
输出：
{1, 2, 5, 6}

9. 遍历集合

s1 = {11,22,33,44}
for i in s1:
    print(i)
输出：
33
11
44
22