Day02-进制与基本数据类型介绍

一.进制介绍

　　a.进制：进制也就是进位制，是人们规定的一种进位方法。 对于任何一种进制---X进制，就表示某一位置上的数运算时是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

　　b.进位制/位置计数法是一种记数方式，故亦称进位记数法/位值计数法，可以用有限的数字符号代表所有的数值。可使用数字符号的数目称为基数(en:radix)或底数，基数为n，即可称n进位制，简称n进制。现在最常用的是十进制，通常使用10个阿拉伯数字0-9进行记数。

　　　　二进制：它由两个基本数字0，1组成，二进制数运算规律是逢二进一。

　　　　八进制：它由八个基本数字0，1，2 , 3 ，4 ，5 ，6 ，7 组成，八进制数运算规律是逢八进一

　　　　十进制：它由十个基本数字0，1，2,，3，4, 5，6，7, 8, 9,组成，十进制数运算规律是逢十进一

　　　　十六进制：它由十六个字符0～9以及A，B，C，D，E，F组成（它们分别表示十进制数10～15），十六进制数运算规律是逢十六进一

　　c.文件存储到硬盘上，硬盘上面的数据是是以二进制的形式保存的。（也就是01001000方式）

　　d.每个编码都有属于自己的对应关系表，读取时将硬盘上保存的二进制文件对应的编码的汉字，输出之后看到的是转换完成的字符串或者是已十六进制展示的二进制数据

flie文件

sdkah但空间上电脑付款了能力得分

 

#输出对应的编码的汉字
f = open('flie','r',encoding='utf-8')
data = f.read()
f.close()
print(data)

#输出的信息：sdkah但空间上电脑付款了能力得分

 

#以十六进制展示二进制数据信息
f = open('flie','rb')
data1 = f.read()
f.close()
print(data1)

#输出的信息：b'sdkah\xe4\xbd\x86\xe7\xa9\xba\xe9\x97\xb4\xe4\xb8\x8a\xe7\x94\xb5\xe8\x84\x91\xe4\xbb\x98\xe6\xac\xbe\xe4\xba\x86\xe8\x83\xbd\xe5\x8a\x9b\xe5\xbe\x97\xe5\x88\x86'

二.类与对象概要

　　类是面向对象程序设计中的概念，是面向对象编程的基础。

　　类的实质是一种数据类型，类似于int、char等基本类型，不同的是它是一种复杂的数据类型。因为它的本质是类型，而不是数据，所以不存在于内存中，不能被直接操作，只有被实例化为对象时，才会变得可操作。

 

str  # 类str
name1 = "huangzhong1" #str类的对象,
name1.split()　　　　　#类str的功能
name1.strip()
name2 = "huangzhong2"　#str类的对象
name2.split()
name2.strip()
name3 = "huangzhong3"
name3.split()
name3.strip()

int
num = 19 #类int的对象，每个类对象的功能需要到该类里面查找

list
li = [1,2,3,43]# 类list的对象，每个类对象的功能需要到该类里面查找

dict 
dic = {'k1': 'v1'}#类dict的对象，每个类对象的功能需要到该类里面查找

 

三.基本数据类型之字符串功能（字符串是不可变类型）

1.字符串首字母变大写

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

# 输出内容： tom

2.将所有大写变小写

name = 'ToM'
v = name.casefold()    #可以将其他语言的大写变成小写
print(v)

# 输出内容：tom

3.将所有大写变小写

name = 'ToM'  # 只能转换英文的大写
v = name.lower()
print(v)

# 输出内容：tom

4.文本居中，参数1：表示总长度，参数2：表示空白处填充的字符（只能添加长度为1的字符）

name = 'tom'
v = name.center(20，'*')
print(v)

# 输出内容：********tom*********

5.表示传入值在该字符串中出现的次数,参数1：表示要查找的值（子序列）,参数2：表示起始位置(索引),参数3：表示结束位置(索引)

name = 'alvjiuovnalvnxnjalgdfgfvd'
v = name.count('n')
print(v)
# 输出内容：3
name = 'alvjiuovnalvnxnjalgdfgfvd'
v = name.count('al',9)
print(v)
# 输出内容：2
name = 'alvjiuovnalvnxnjalgdfgfvd'
v = name.count('al',9,20)
print(len(name))
print(v)
# 输出内容：25 2

6.是否以什么结尾

name = 'tom'
v = name.endswith('m')
print(v)
# 输出内容：True

7.是否已什么开头

name = 'tom'
v = name.startswith('t')
print(v)
# 输出内容：True

8.encode转换成字节

name = '成飞'
v = name.encode(encoding='utf-8')#字节类型
print(v)
# 输出内容：b'\xe6\x88\x90\xe9\xa3\x9e'

name = '成飞'
v = name.encode(encoding='gbk')#字节类型
print(v)
# 输出内容：b'\xb3\xc9\xb7\xc9'

9.找到制表符\t进行替换（包含前面的值，\n）

name = 'tom\t123\t0\njim\t123\t1'
v = name.expandtabs(10)
print(v)
# 输出内容：
tom 123 0
jim 123 1

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

name = 'tom'
v = name.find('o')# find 查找如果子序列不在字符串里面不报错，返回值-1
print(v)
# 输出内容：1

name = 'tom'
v = name.index('j')  #index 查找如果子序列不在字符串里面报错
print(v)
# 输出内容：不存在报错

11.字符串格式化

li = '我叫：{0},性别：{1},年龄：{2}'
new_li = li.format('成飞','男',18)
print(new_li)
# 输出内容：我叫：成飞,性别：男,年龄：18

li = '我叫：{name},性别：{gender},年龄：{age}'
new_li = li.format(name='成飞',gender='男',age=18)
print(new_li)
# 输出内容：我叫：成飞,性别：男,年龄：18

li = '我叫：{name},性别：{gender},年龄：{age}'
new_li = li.format_map({'name':'chengfei','gender':'nan','age':18})
print(new_li)
# 输出内容：我叫：成飞,性别：男,年龄：18

  12. 是否是数字、汉字.

name = 'tom1飞'
v = name.isalnum()# 汉字，字母、数字
print(v)
# 输出内容：True

v2 = name.isalpha()# 汉字，字母
print(v2)
# 输出内容：Flase

13. 判断是否是数字

num = '二'
v = num.isdecimal()    #只能判断阿拉伯数字
v1 = num.isdigit()     #阿拉伯数字、'②'
v2 = num.isnumeric()   #阿拉伯数字、'②'、中文数字（一、二）
print(v)
print(v1)
print(v2)
# 输出内容：
False
False
True

14. 是否是表示符(是否能作为变量名使用，但是不能判断内部关键字)

name = 'tom1'
v = name.isidentifier()  #  True
print(v)
name = '1tom'
v = name.isidentifier()  #  False
print(v)
name = 'for'
v = name.isidentifier()  # 不能判断内部关键字
print(v)
# 输出内容: 
True
Flase
true

15.是否全部是小写

name = 'jiM'
v = name.islower()
print(v)
# 输出内容：False

name = 'TOM'
v = name.isupper() # 是否全部是大写
print(v)
# 输出内容：True

16.全部变成大写

name = 'toM'
v = name.upper()
v1 = name.lower()  #全部变小写
print(v)
print(v1)

17.是否包含隐含的xx（打印不出来的，例如：\t）

name = '我叫成飞，\t性别:，'
v = name.isprintable()
print(v)
# 输出内容：False

18.是否全部是空格

name = '  '
v = name.isspace()
print(v)
# 输出内容： True

19.元素的拼接（元素必须是字符串或者是字符）

name = 'tom'
v = '_'.join(name)
print(v)
name = ['tom','jim','bob'] # 数字不可以拼接
v = '和'.join(name)
print(v)
# 输出内容：
t_o_m
tom和jim和bob

20.左右填充（center(居中) ljust（将值放在左边，后面填充）rjust）

name = '成飞'
v = name.ljust(20,'*')
print(v)
name = 'chengfei'
v = name.rjust(15,'A')
print(v)
# 输出内容：
成飞******************
AAAAAAAchengfei

21. 对应关系 + 翻译

num = str.maketrans('abcde','12345')
name = 'asfgvxkocb'
v = name.translate(num)
print(v)
# 输出内容：1sfgvxko32

22. 分割，保留分割的元素

li = 'chengfei$tom$jim'
v = li.partition('$')
print(v)
# 输出内容：  ('chengfei', '$', 'tom$jim')

23.替换（第三个参数表示替换的数量）

li = '$chengfei$tom$jim'
v = li.replace('$','@')
print(v)
v = li.replace('$','@',2)
print(v)
3 输出内容：
@chengfei@tom@jim

　@chengfei@tom$jim

24，移除空白,\n,\t，自定义

name = 'chengfei\n'# 空白,\n,\t
v = name.strip()
print(v)
# 输出内容：chengfei

25.大小写转换

name = 'tOm'
v = name.swapcase()
print(v)
# 输出内容：ToM

26.填充0

name = 'tom'
v = name.zfill(10)
print(v)
# 输出内容：0000000tom

27.字符串额外的功能

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

四.基本数据类型之整数功能

   1. 当前整数的二进制表示，最少位数

num = 4   #  二进制表示 100
print(num.bit_length())
# 输出内容： 3

2. 获取当前数据的字节表示(第一个参数表示已几个字节显示，little表示当前数据放在开头，big表示放在末尾)

num = 20
new_num = num.to_bytes(5,byteorder='little')
age = num.to_bytes(5,byteorder='big')
print(new_num)
print(age)
# 输出内容：
b'\x14\x00\x00\x00\x00'

　b'\x00\x00\x00\x00\x14'

五.基本数据类型之布尔值功能

num = 0 # bool值为False 其他数字都为True
user_str = ''
li = []
dic = {}
a = bool(li)
print(a)   #空内容为False，其他都为True

六.基本数据类型之列表功能（可变类型）

ps：执行功能的时候，执行完功能之后接收一下该值，看是否可以接收到值，如果能接收到值，则该功能新返回一个值，如果接收不到值则自身发生变化

1.追加

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.append('袁志强') # 接收不到值，返回值为None，列表自身发生变化
print(v)
print(user_list)
# 输出内容：　　
None

　['成飞', '胡晓飞', '于龙', '杨彦龙', '袁志强']

2.清空

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
user_list.clear()
print(user_list)

3.拷贝（浅拷贝）

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.copy()
print(v)
print(user_list)
# 输出内容：

['成飞', '胡晓飞', '于龙', '杨彦龙']
['成飞', '胡晓飞', '于龙', '杨彦龙']

4.计算列表里面的元素出现的次数（计数）

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.count('成飞')
print(v)

 5.扩展原列表

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
user_list.extend(['袁志强','何鑫'])
print(user_list)
# 输出内容：
['成飞', '胡晓飞', '于龙', '杨彦龙', '袁志强', '何鑫']

6.查找元素索引，没有时报错

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.index('成飞')
print(v)

7.删除并获取元素 - g根据索引删除

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.pop(0)
print(v)
print(user_list)
# 输出内容：

 　成飞
　['胡晓飞', '于龙', '杨彦龙']

8.删除  - 值

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.remove('于龙')   #  不能获取该值
print(user_list)
print(v)
# 输出内容：

　　['成飞', '胡晓飞', '杨彦龙']
　　None

9.翻转

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list.reverse() #  将本身翻转，不获取新值
print(v)
print(user_list)
# 输出内容：

　　　None
　　　['杨彦龙', '于龙', '胡晓飞', '成飞']

10.排序

# 从小到大

num = [1,66,6,18,33]
num.sort()
print(num)

# 从大到小
num.sort(reverse=True)
print(num)

# 输出内容：

[1, 6, 18, 33, 66]
[66, 33, 18, 6, 1]

11.列表额外的功能

#索引
user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list[0]
print(v)
切片
user_list = ['成飞','胡晓飞','于龙','杨彦龙']
v = user_list[0::2]
print(v)
#删除
user_list = ['成飞','胡晓飞','于龙','杨彦龙']
del user_list[0]
print(user_list)
# for 循环
user_list = ['成飞','胡晓飞','于龙','杨彦龙']
for i in user_list:
     print(i)
#修改(重新赋值)
user_list = ['成飞','胡晓飞','于龙','杨彦龙']
user_list[0] = 'chengfei'
print(user_list)

七.基本数据类型之元组功能（不可变类型）

1.元素出现的次数

user_tuple = ('tom','jim','bob','chengfei')
v = user_tuple.count('jim')
print(v)

2.获取第一个值所在的索引位置，（有多个时，只能获取第一个）

user_tuple = ('tom','jim','bob','chengfei','jim')
v = user_tuple.index('jim')
print(v)

  3.元组额外的功能

# 索引
user_tuple = ('tom','jim','bob','chengfei','jim')
v = user_tuple[0]
print(v)
# 切片
user_tuple = ('tom','jim','bob','chengfei','jim')
v = user_tuple[0::2]
print(v)
# for 循环
user_tuple = ('tom','jim','bob','chengfei','jim')
for i in user_tuple:
    print(i)

八.基本数据类型之字典功能（可变类型）

1.清空

dic = {'name':'chengfei','age':18,'gender':'nan',}
dic.clear()
print(dic)

2.浅拷贝

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.copy()
print(v)
print(dic)
# 输出内容：

{'name': 'chengfei', 'gender': 'nan', 'age': 18}
{'name': 'chengfei', 'gender': 'nan', 'age': 18}

3.根据key获取指定的value；不存在时不报错,返回None，添加第二个参数之后返回该参数的值。

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.get('name')
print(v)
dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.get('times',1111)   #  不存在时，第二个参数表示返回指定的值
print(v)
# 输出内容：

　　chengfei
　　111

4.删除并获取对应的value值

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.pop('name')
print(v)
print(dic)
# 输出内容:

　　chengfei
　　{'gender': 'nan', 'age': 18}

5.随机删除键值对，并获取到删除的键值(ps:随机的)

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.popitem()
print(v)
print(dic)
# 输出内容：

('age', 18)
{'name': 'chengfei', 'gender': 'nan'}

dic = {'name':'chengfei','age':18,'gender':'nan',}
k,v = dic.popitem()
print(k,v)
print(dic)
# 输出内容：

gender nan
{'name': 'chengfei', 'age': 18}

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.popitem()
print(dic)
print(v[0],v[1])
# 输出内容：

{'age': 18, 'name': 'chengfei'}
gender nan

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

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.setdefault('stature',170)
print(v)  #  输出value值
print(dic)
# 输出内容：

170
{'age': 18, 'gender': 'nan', 'stature': 170, 'name': 'chengfei'}

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.setdefault('name','jim') # 存在name ，不做任何操作
print(v)
print(dic)
# 输出内容：

chengfei
{'gender': 'nan', 'name': 'chengfei', 'age': 18}

7. 批量增加或修改

dic = {'name':'chengfei','age':18,'gender':'nan',}
v = dic.update({'stature':170,'weight':60})
print(v)  # 不获取值，字典本身变化
print(dic)
# 输出内容：

None
{'age': 18, 'stature': 170, 'name': 'chengfei', 'weight': 60, 'gender': 'nan'}

dic = {'name':'chengfei','age':18,'gender':'nan',}
dic.update({'stature':170,'weight':60,'name':'jim'})
print(dic)

# 输出内容：
{'weight': 60, 'gender': 'nan', 'stature': 170, 'age': 18, 'name': 'jim'}

8.循环生成一个字典

dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)
dic = dict.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 456 # 可以修改字典里面的value值
print(dic)
# 输出内容：

{'k3': 123, 'k2': 123, 'k1': 123}
{'k3': 123, 'k2': 123, 'k1': 456}

当参数二是个可变类型的**，每个keys对应的是**的内存地址，当内存地址的**改变时，所有的都会改变。

dic = dict.fromkeys(['k1','k2','k3'],[1,])
dic['k1'].append('123')
print(dic)

# 输出内容：{'k2': [1, '123'], 'k1': [1, '123'], 'k3': [1, '123']}

9.额外的字典的功能

# 字典可以嵌套并且字典的keys必须是不可变类型，元组是可以作为的字典的keys,true、False、数字也可以作为keys（0和1会和False、True重复）
# 索引
# del dic['k1']

九.基本数据类型之集合功能

1.s1中存在 s2中不存在的

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
v = s1.difference(s2)
print(v)
# 输出内容：{'chengfei', 'kunsheng'}

s1中存在 s2中不存在的,然后对s1清空，然后在重新赋值(后期学习会经常使用)

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
s1.difference_update(s2)
print(s1)
# 输出内容：{'kunsheng', 'chengfei'}

2.s2中存在，s1中不存在的

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
v = s2.difference(s1)
print(v)
# 输出内容：{'yanmin'}

3.s2中存在，s1中不存在的并且s1中存在 s2中不存在的

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
v = s1.symmetric_difference(s2)
print(v)
# 输出内容：{'yanmin', 'kunsheng', 'chengfei'}

a.s2中存在，s1中不存在,s1中存在，s2中不存在,然后对s1清空，然后在重新赋值

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
s1.symmetric_difference_update(s2)
print(s1)

# 输出内容：{'yanmin', 'kunsheng', 'chengfei'}

4.交集

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
v = s1.intersection(s2)
print(v)
# 输出内容：{'xiaofei', 'jim', 'bob', 'tom'}

5.并集

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s2 = {'tom','jim','bob','xiaofei','yanmin'}
v = s1.union(s2)
print(v)
# 输出内容：{'kunsheng', 'yanmin', 'tom', 'jim', 'xiaofei', 'chengfei', 'bob'}

6.移除

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
v = s1.discard('tom')
print(v)   #  接收不到值，返回值为None，集合自身发生变化
print(s1)
s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s1.remove('tom')
print(s1)

7.批量增加

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
s1.update({'yulong','lixin'})
print(s1)

8.随机删除集合里面的元素

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}# 随机删除集合里面的元素
v = s1.pop()
print(v)
print(s1)

9.集合额外的功能

　for循环

s1 = {'tom','jim','bob','xiaofei','chengfei','kunsheng'}
for i in s1:
    print(i)

#集合里面只能元组，其他不能嵌套

十.range,enumrate

1.输出1-10的数字:
　python2中 range（1,11）立即生成1-10的数字  例：v = range（1,11）print（v）
　python3 中不会立即生成，只有循环迭代，才会一个一个显示

for i in range(1,11):   #输出1-10
    print(i)

for i in range(1,11,2): #输出奇数
    print(i)

for i in range(10,0,-1): #倒着输出1-10
    print(i)

range总结：

- 2.7：
range(),立即生成
xrange()
不会立生成，迭代之后才一个一个创建；
- 3.x
range() 不会立生成，迭代之后才一个一个创建；
range 三个参数：第一个：起始位置 第二个：结束位置  第三个步长

range示例：

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
for i in range(0,len(user_list)):
    ele = user_list[i]
    print(ele)
# 输出内容：

  成飞
  胡晓飞
  于龙
  杨彦龙

user_list = ['成飞','胡晓飞','于龙','杨彦龙']
for i in range(0,len(user_list)):
    ele = user_list[i]
    print(i+1,ele)
#输出内容：

　1 成飞
　2 胡晓飞
　3 于龙
　4 杨彦龙

2.enumerate额外生成一列有序的数字 示例

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)