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', '1234567')  # 对应关系字典
#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','1111111')
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','123123','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)