python初识（二）

目录：

• 进制
• 基本数据类型
  • 整形
  • 布尔值
  • 字符串
  • 列表
  • 元祖
  • 字典
  • 集合
• range & enumerate

一、进制

　　二进制转换十进制计算：

　　十进制：==47

　　一个字节公式：==128 64 32 16 8 4 2 1

　　二进制： == 0    0   1   0 1 1 1 1

　　1、二进制（0b）：

　　　　 a.表现形式：0、1 --〉11 ==十进制3

　　　　 b.python中的应用：　　　　

十进制:a = 5

转换：bin(a)

结果：'0b101' ==〉 cpu处理：00000101

　　2、八进制（0o）：

　　　　 a.表现形式：0、1、2、3、4、5、6、7、8 -->11 ==十进制9

　　　　 b.python中的应用：　　　　

十进制:a = 11
转换：oct(a)
结果：'0o13'   ==〉 cpu处理：000001101

　　3、十进制　

a.表现形式：0、1、2、3、4、5、6、7、8、9、10 -->11 ==十进制11

　　　　 b.python中的应用：　　　　

十进制:a = 11 

结果：11  ==〉 cpu处理：000001101

注意：其实在python3里所留代码都是转换成十六进制存储的 

　　4、十六进制（0x）

　　　　 a.表现形式：0、1、2、3、4、5、6、7、8、9、 A、 B、C、D、E、F -->A ==十进制11

　　　　 b.python中的应用：　　　　

十进制:a = 20
转换：hex(a)
结果：'0x14' ==〉 cpu处理：000001010

5、总结：

a. 硬盘上保存数据：为二进制文件，python3展示的时候为了方便，展示的时候为了方便会显示十六进制

b. cpu处理读取：01010101010101010101 -> 对应的编码的汉字 --> xx
c. python3：

- 转换完成的字符串
- 以十六进制展示的

二、  基本数据类型

1、整形(int)

没啥好说的，直接上代码，哈哈。

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 int 整数类型
 '''

 '''
 1. 当前整数的二进制表示，最少位数
 '''
 age = 4  # 二进制100
 print(age.bit_length())
 #结果为3

 '''
 2. 获取当前数据的字符表示
 '''
 age = 15
 v = age.to_bytes(10,byteorder='big')
 print('获取当前数据的字符表示big', v)  # b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f'
 v = age.to_bytes(10,byteorder='little')
 print('获取当前数据的字符表示little', v)  # b'\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 '''
 ps. 显示为十六进制0f为15， little为从右边补0， big为从左边补0
     0f ==> 二进制为 0000 1111 代表一个字节码
 '''

2、布尔值(bool)

代码都不用上，简单吧。

当传入的对象为空时，为False -->0, 否则为True --> 1

例如：为False情况，如下：
v = 0
v = ''
v = []
v = {}
v = ()
v = False
其他值均为True 或者说是 1。

3、字符串(str)

a. 常用str类的实例对象(方法)有：

# name.upper()
# name.lower()
# name.split()
# name.find()
# name.strip()
# name.startswith()
# name.format()
# name.replace()
# "shuyang".join(["aa",'bb'])

b. __add__ 功能， str类的隐藏参数，详细为学习到面向对象，在详细分析目前用途为 v = v1 + v2 实际就是条用__add__参数

c. 代码实例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 字符串内置方法调用
 '''

 '''
 a. 字符大写变小写，casefold可以转目前所有字符，大写变小写，如:德语
 lower()只能是英文的大写便小写。
 注意：中文没有大小写
 '''
 name = 'Alex'
 v = name.casefold()
 v1 = name.lower()
 print('casefold and lower', v, v1)

 '''
 b. 首字母大写、全部变大写
 '''
 name1 = 'alex'  # str类的对象
 # capitalize 字符串字母大写
 # name1自身不变，capitalize方法会生成一个新的值
 v2 = name1.capitalize()
 print('首字母大写',name1,v2)
 # 全部变大写
 name1 = 'alex'
 v2 = name1.upper()
 print('全部变大写',name1,v2)

 '''
 c. 文本居中,默认为空格分隔, 及左右空格
 center， rjust，ljust
 参数1：表示总长度
 参数2: 空白处填充的字符（长度为1）
 '''
 name2 = 'alex'
 v3 = name2.center(20)
 print('文本居中', v3)
 v3 = name2.center(20,'-')
 print('文本居中1', v3)
 v3 = name2.center(20,'*')
 print('文本居中2', v3)
 v3 = name2.center(20,'行')
 print('文本居中3', v3)
 v3 = name2.ljust(20,'*')
 print('从左边开始20位，不够补*', v3)
 v3 = name2.rjust(20,'-')
 print('从右边开始20位，不够补-', v3)

 '''
 d. 字符串出现的关键字统计
 参数1:要查找的值（子序列)
 参数2:起始位置（索引）
 参数3:结束位置（索引）
 '''
 name3 ='fafafadffgfdgdaerwerweqweqeaaaa'
 v4 = name.count('a')
 print('字符串出现的关键字统计', v4)
 v4 = name.count('we',12)
 print('字符串出现的关键字统计', v4)
 v4 = name.count('we',20)
 print('字符串出现的关键字统计', v4)

 '''
 e.是否以XX结尾，是否已XX开头
 '''
 name4 = 'alex'
 #以XX结尾
 v5 = name.endswith('ex')
 print('以XX结尾', v5)
 #以XX开头
 v5 = name.startswith('ex')
 print('以XX开头', v5)

 '''
 f. encode
 str = "人生苦短，我用python";
 str_utf8 = str.encode("UTF-8")
 str_gbk = str.encode("GBK")

 print(str)

 print("UTF-8 编码：", str_utf8)
 print("GBK 编码：", str_gbk)

 print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
 print("GBK 解码：", str_gbk.decode('GBK','strict'))
 '''

 '''
 g. 找到制表符\t，进行替换（包含前面的值）
 PS:\n
 '''
 name6 = 'al\te\tx\nalex\tuu\tkkk'
 v7 = name.expandtabs(20)
 print('找到制表符/t，进行替换（包含前面的值）',v7)

 '''
 h. 找到指定子序列的索引位置:
 find：不存在返回-1
 index: 不存在报错
 '''
 name7 = 'alex'
 v8 = name7.find('o')
 print('找到指定子序列的索引位置:不存在返回-1',v8)
 v8 = name7.index('a')
 print('找到指定子序列的索引位置:不存报错',v8)

 '''
 i. 字符串格式化
 '''
 # tp1 = '我是:%s 年龄:%s 性别:%s'
 tpl = '我是:{0} 年龄:{1} 性别:{2}'
 v9 = tpl.format('舒阳', 19, '男')
 print('字符串格式化', v9)

 tpl = '我是:{name} 年龄:{age} 性别:{gender}'
 v9 = tpl.format(name = '舒阳',age = 19, gender ='男')
 print('字符串格式化2', v9)

 tpl = '我是:{name} 年龄:{age} 性别:{gender}'
 v9 = tpl.format_map({'name':'舒阳','age':19, 'gender':'男'})
 print('字符串格式化2', v9)

 '''
 g. 是否是数字、汉字
 '''
 name9 = 'alex8汉字'
 v10 = name9.isalnum()  # 字，数字, 字母
 print('isalnum是否是数字、汉字', v10)
 v10 = name9.isalpha()  # 字母
 print('isalpha是否是字母', v10)

 '''
 k. 判断是否是数字
 '''
 # num = 123
 # num = '二'
 num = '②'
 v11 = num.isdecimal()  # '123'
 print('isdecimal判断是否是数字', v11)
 v11 = num.isdigit()  # '123', '②'
 print('isdigit判断是否是数字', v11)
 v11 = num.isnumeric()  # '123'，'二'，'②'
 print('isnumeric判断是否是数字', v11)

 '''
 l. 是否是表式符
 '''
 n = 'name'
 v12 = n.isidentifier()
 print('是否是制表符', v12)

 '''
 m. 是否全部是小写 or 大写
 '''
 # 是否全部是小写
 name13 = 'alex'
 v13 = name13.islower()
 print('是否全部是小写', v13)
 # 是否全部是大写
 name13 = 'ALEX'
 v13 = name13.isupper()
 print('是否全部是大写', v13)

 '''
 n. 是否包含隐含的xx，如：/t /n /r
 '''
 name14 = "钓鱼要掉刀鱼，\n刀鱼要到岛上掉"
 v14 = name14.isprintable()
 print('是否包含隐含的xx，如：/t /n /r', v14)

 '''
 o. 是否全部是空格
 '''
 name15 = '      '
 v15 = name.isspace()
 print('是否全部是空格', v15)

 '''
 p. 元素拼接（元素字符串） 五星重要
 '''
 name16 = 'alex'
 v16 = '_'.join(name16)
 print('元素拼接（元素字符串）', v16)
 # ps. list使用join拼接
 name_16_list = ['a', 'b', 'c', 'd']
 v16 = '搞'.join(name_16_list)
 print('元素拼接（元素list）', v16)

 '''
 q. 对应关系 + 翻译
 '''
 m = str.maketrans('abcedfg', '')  # 对应关系字典
 #print(m) ## {97: 49, 98: 50, 99: 51, 101: 52, 100: 53, 102: 54, 103: 55}
 name17 = 'abcedfgfadfafafaagfgwerwrwqrqeoiwr'
 v17 = name17.translate(m)
 print('对应关系 + 翻译', v17)

 '''
 r. 分割，保留分割的元素
 只能分割从左数第一个匹配
 ('a', 'SB', 'bSBc')
 '''
 content = 'aSBbSBc'
 v18 = content.partition('SB')
 print('分割，保留分割的元素', v18)
 #分割不保留元素，用spilt
 #参数一:关键字
 #参数二:从左分割几次，有默认值 -1，全切割
 content = 'aSBbSBc'
 v18 = content.split('SB', 1)
 print('分割不保留元素，用spilt', v18)

 '''
 s. 替换
 参数1: old_word
 参数2: new_word
 参数3: 替换个数，从左开始
 '''
 content1 = 'aSBbSBc'
 v19 = content1.replace('SB', 'Love')
 print('替换', v19)
 v19 = content1.replace('SB', 'Love', 1)
 print('替换，替换个数1', v19)

 '''
 t. 移除空白，默认/n/t/r,
 参数一:自定义移除str
 '''
 name20 = 'alex\t'
 v20 = name.strip()
 print('移除空白', v20)

 '''
 u. 大小写转换
 '''
 name21 = "Alex"
 v21 = name.swapcase()
 print('大小写转换', v21)

 '''
 v.填充0
 '''
 name22 = 'Alex'
 v = name.zfill(20)
 print('填充0', v)

4、列表（list）

list为可变类型字符与（int，str，list，dict）一样

切片[::]
remove删除 --值
for循环读取
list的嵌套
len()长度
更新

ps.以上东西已在python初识（一）中的python数据类型初识中，详细介绍，就不重复了。下面我们学点新东西，如下：

a.代码示例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 list 列表，为可变类型字符（int，str，list，dict）
 '''

 '''
 a. list追加
 '''
 #建立变量
 user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
 user_list.append('刘铭')
 print('list追加', user_list)

 '''
 b.list清空
 '''
 user_list = ['李泉','刘一','刘康','豆豆','小龙']
 user_list.clear()
 print('list清空', user_list)

 '''
 c.list拷贝（浅拷贝）
 '''
 user_list = ['李泉','刘一','刘康','豆豆','小龙']
 v = user_list.copy()
 print('list拷贝（浅拷贝）', v)

 '''
 d.list计数
 '''
 user_list = ['李泉','刘一','刘康','豆豆','小龙','李泉']
 v = user_list.count('李泉')
 print('list计数', v)

 '''
 e. list扩展原列表
 '''
 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙']
 user_list.extend(['郭少龙','郭少霞'])
 print('list扩展原列表', user_list)

 '''
 f. list查找元素索引，有报错
 '''
 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙']
 #v = user_list.index('李海')  #有报错
 print('list查找元素索引，没有报错', v)

 '''
 g. list删除并且获取元素 - 索引
 '''
 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙']
 v = user_list.pop(1)
 print('删除并且获取元素的值', v)
 print('list删除并且获取元素的列表', user_list)

 '''
 f. list删除 - 值
 '''
 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙']
 user_list.remove('刘一')
 print('list删除', user_list)

 '''
 g.  list翻转
 '''
 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙']
 user_list.reverse()
 print('list翻转', user_list)

 '''
 h. list排序： 欠参数key=None
 '''
 nums = [11,22,3,3,9,88]
 print('原始list',nums)
 # 排序，从小到大
 nums.sort()
 print('list排序，从小到大',nums)
 # 从大到小
 nums.sort(reverse=True)
 print('从大到小',nums)

 '''
 i 插入
 参数1: 索引位置
 参数2: 插入的值
 '''
 li = ['eric','alex','tony']
 li.insert(0,'Tony')
 print('插入',li)

 '''
 j. list删除取值 --索引
 '''
 li = ['eric','alex','tony']
 v = li.pop(1)
 print('list删除的值', v)
 print('list删除', li)

 '''
 k. del多个删除 -- 索引
 '''
 li = ['eric','alex','tony']
 #del li[2]
 li[0:2] # 0 =<x < 2
 print('list删除', li)

5、元祖（tuple）

　　元祖不可被修改的列表，为不可变类型，是目前python基础类型中唯一的不可变类型，它一旦创建，便不能再修改，所以又叫只读列表。

a.元祖（tuple）嵌套列表(list)，子序列不能修改，list可以修改，怎么修改呢?

简单演示：
user_tuple = ('alex','eric','seven',['陈涛','刘浩','赵芬芬'],'alex')
user_tuple[0] = 123 不对，不可变类型
user_tuple[3] = [11,22,33] 不对，不可变类型
user_tuple[3][1] = '刘一'
print(user_tuple)

b.元组最后，加逗号,因为一个元素被()默认不是元祖（潜规则）

简单演示：
li = ('shuyang',)
print(li)

c. 代码示例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 tuple元祖:元祖不可被修改的列表，为不可变类型
 '''
 user_tuple = ('alex', 'eric', 'seven', 'alex')
 # a、元祖获取个数
 v1 = user_tuple.count('alex')
 print('元祖获取个数', v1)
 # b、元祖获取第一个索引的位置
 v2 = user_tuple.index('alex')
 print('元祖获取第一个索引的位置', v2)

6、字典（dict）

a.字典可以嵌套
b.字典key: 必须是不可变类型,且Ture和int(1)不能同时使用

简单演示：
dic = {
'k1': 'v1',
'k2': [1,2,3,],
(1,2): 'lllll',  # 元祖为不可变类型，所以可以，但我尽量不使用这种方式
1: 'fffffffff',
111: 'asdf',
}
print(dic)

dic = {'k1':'v1'}
del dic['k1']

c.代码示例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 dict 字典
 '''
 '''
 a. dict清空
 '''
 dic = {'k1':'v1','k2':'v2'}
 dic.clear()
 print('dict清空', dic)

 '''
 b.dict浅拷贝
 '''
 dic = {'k1':'v1','k2':'v2'}
 v = dic.copy()
 print('dict浅拷贝', v)

 '''
 c. dict根据key获取指定的value；不存在不报错
 '''
 dic = {'k1':'v1','k2':'v2'}
 v = dic.get('k1111',1111)
 # v = dic['k1111']  # 报错
 print('dict根据key获取指定的value；不存在不报错', v)

 '''
 d. dict删除并获取对应的value值
 '''
 dic = {'k1':'v1','k2':'v2'}
 v = dic.pop('k1')
 print('dict删除并获取对应的value值', v)
 print('dict删除后字典', dic)

 '''
 e. dict随机删除键值对，并获取到删除的键值
 '''
 dic = {'k1':'v1','k2':'v2'}
 v = dic.popitem()
 print('dict删除并获取对应的value值', v)
 print('dict删除后字典', dic)
 '''
 # 花式取值1
 k,v = dic.popitem() # ('k2', 'v2')
 print(dic)
 print(k,v)

 # 花式取值2
 v = dic.popitem() # ('k2', 'v2')
 print(dic)
 print(v[0],v[1])
 '''

 '''
 f. dict增加默认值，如果存在则不做操作
 '''
 dic = {'k1':'v1','k2':'v2'}
 dic.setdefault('k3','v3')
 print('dict增加默认值，不存在，添加', dic)
 dic.setdefault('k1','')
 print('dict增加默认值，存在，不变', dic)

 '''
 g. dict批量增加或修改
 '''
 dic = {'k1':'v1','k2':'v2'}
 dic.update({'k3':'v3','k1':'v24'})
 print('dict批量增加或修改', dic)

 '''
 h. 批量创建方式
 参数1: key值列表
 参数2: 所有key默认初始值val值
 '''
 dic = dict.fromkeys(['k1','k2','k3'],123)
 print('dict批量创建方式', dic)
 #修改
 dic['k1'] = 'asdfjasldkf'
 print('dict批量创建方式--修改', dic)
 '''
 # 注意：
 dic用fromkeys创建方法。如果value值为list，因所有key指向value值是同一个
 内存地址，所以，修改list中的值时，所有key都会跟着变更。故value值为list，
 修改dic的value时，必须整个list重新赋值，获取新的内存地址。
 dic = dict.fromkeys(['k1','k2','k3'],[1,])
 {
    k1: 123123213, # [1,2]
    k2: 123123213, # [1,]
    k3: 123123213, # [1,]
 }
 dic['k1'].append(222)
 print(dic)
 '''

7、集合（set）

a. for循环迭代读取集合

s1 = {"alex",'eric','tony','李泉','李泉11'}
for i in s1:

print(i)

b. 集合的嵌套

s1 = {"alex",'eric','tony','李泉','李泉11',(11,22,33)}
for i in s1:

print(i)

c. 不是太常用的set类的方法

isdisjoint     判断交集，是返回False，否返回True
issubset(x)   判断 集合s 是否是 集合x 子集
issuperset(x)  判断 集合x 是否是集合s的子集
pop      随机删除并返回集合s中某个值，注意，因为set是无序的，不支持下标操作，没有所谓的最后一个，pop()移除随机一个元素，这和其他数据结构不同
remove 将 x 从集合s中移除，若x不存在，会引发错误

d. 代码示例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 set 集合
 不可重复的列表，属于可变类型
 '''

 '''
 a. 创建
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s2 = {"alex",'eric','tony','刘一'}
 '''

 '''
 b. s1中存在，s2中不存在
 '''
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s2 = {"alex",'eric','tony','刘一'}
 v = s1.difference(s2)
 print('s1中存在，s2中不存在', v)

 '''
 c. s1中存在，s2中不存在
 '''
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s2 = {"alex",'eric','tony','刘一'}
 s1.difference(s2)
 print('s1中存在，s2中不存在', s1)
 #s1中存在，s2中不存在，然后对s1清空，然后在重新赋值(重要)
 s1.difference_update(s2)
 print('s1中存在，s2中不存在，然后对s1清空，然后在重新赋值', s1)

 '''
 d. s2中存在，s1中不存在,且s1中存在，s2中不存在，对称差集
 '''
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s2 = {"alex",'eric','tony','刘一'}
 v = s1.symmetric_difference(s2)
 print('对称差集', v)
 # 对称差集，然后对s1清空，然后在重新赋值
 s1.symmetric_difference_update(s2)
 print('对称差集，然后对s1清空，然后在重新赋值', s1)

 '''
 e. 交集
 '''
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s2 = {"alex",'eric','tony','刘一'}
 v = s1.intersection(s2)
 print('交集', v)
 s1.intersection_update(s2)
 print('交集，然后对s1清空，然后在重新赋值', s1)

 '''
 f. 并集
 '''
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s2 = {"alex",'eric','tony','刘一'}
 v = s1.union(s2)
 print('并集', v)

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

 '''
 h. 更新
 '''
 s1 = {"alex",'eric','tony','李泉','李泉11'}
 s1.update({'alex','','fff'})
 print('更新', s1)

三、range & enumerate

1、range生成器

a. python2.7: 立即生成所有数字

range(1,11) # 生成 1,23，，4,56.10
range() 立即生成所有数字,在2.7中range()不是生成器
xrange() 不会立生成，迭代之后才一个一个创建；是生成器

b. python3.x: 不会立即生成，只有循环迭代时，才一个一个生成

range() 不会立生成，迭代之后才一个一个创建；是生成器
for i in range(1,11): #1，2，3，4，5，6，7，8，9，10

print(i)

c. range(开始,结束，步长) range（0,3）== 0,1,2， 可简写为range(3),默认从0开始

参数1: 开始值（int）
参数2: 结束值(int),默认不去
参数3: 步长 -1表示倒着数，可用于反转（负数同理）

d.代码示例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 a. 请输出1-10
 '''
 for i in range(1,11):
      print(i)

 '''
 b. 取1-10 奇数
 '''
 for i in range(1,11,2):
      print(i)

 '''
 c. 取10 - 1
 '''
 for i in range(10,0,-1):
      print(i)

 '''
 d. list花式使用
 '''
 li = ['eric','alex','tony']
 for i in range(0,len(li)):
     ele = li[i]
     print(ele)

 for i in range(0,len(li)):
     print(i + 1, li[i])

2、enumerate

enumerate()额外生成一列有序的数字
参数1:可迭代对象
参数2：开始值定制

a.代码示例详解

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Shu Yang Wang

 '''
 enumerate额外生成一列有序的数字
 '''

 '''
 使用1：list加序号
 '''
 li = ['eric','alex','tony']
 for i,ele in enumerate(li,1):
     print(i, ele)

 v = input('请输入商品序号：')
 v = int(v)
 item = li[v-1]
 print(item)