数据类型
第三章 基础
3.1编码初识
**ascii **256字母没有中文
一个字节 8位
gbk 中国
中文2字节 16位
英文1字节8位
unicode 万国码
前期 2字节 8位
后期变成4个字节 32位
utf-8 可变编码 英文1 欧洲2 亚洲3字符
3.2格式化输出
根据数据交互输出的数据进行交互占位
举例：%s %d %
%s
#%是占位符%s格式化输出字符串
name=input('name')
sex=input('sex')
money=input('moeny')#工资
print(name,sex,money) #直接输出
怎样进行格式化输出呢
print(('%s,%S,%S')%(name,sex,money))
%d
print(('%s,%S,%d')%(name,sex,money))
如果使用input进行格式化输出默认 字符串需要强行转换 如果不转换直接输出就会出现错误
%d输入一个整数（整型）
码云
Git 全局设置:
git config --global user.name "Strawbarry"
git config --global user.email "strawbarry@user.noreply.gitee.com"
创建 git 仓库:
mkdir 19062824029
cd 19062824029
git init#创建一个本地仓库
touch README.md
git add README.md 添加到缓存区
git commit -m "first commit" 提交
git remote add origin https://gitee.com/strawbarry/19062824029.git
git push -u origin master
如果密码输入错误
3.3基础数据类型扩展
一 整型（int）
python 所有的整型都是用于计算和比较的，
二进制和十进制 转换十六进制
1111
8421
15=F= 1111
14=E=1110
13=D=1011
12=C=1100
11=B=1011
10=A=1010
进制之间转换 python
二进制转十进制
print(int("1111",2));
#15
print(int("6f",16));
#111
print(int("157",8))
#111
十进制转二进制
bin（）二进制转换
bin(10);
format(10,"08b")#十进制转8位二进制
十进制转八进制
oct八进制转换
v_code=15
x=oct(v_code)
x=format(v_code, '#o') # '0o17'，
等效于：x=oct(v_code)
y=format(v_code, 'o') # '17'
十进制转16进制
hex（）16转换
v_code=15
x=format(v_code, '#x') # '0xf'，
等效于：x=hex(v_code)
y=format(v_code, 'x') # 'f'
z=format(v_code, '#X') # 'OXF'
z=format(v_code, 'X') # 'F'
十六进制 123456789ABCDEF
二进制转8进制 三位一转
16进制 八进制
互转需要以先转换二进制方便转换
3.3.1bool str int 强制转换
int ---> bool
i = 100
print(bool(i)) # True # 非零即True
i1 = 0
print(bool(i1)) # False 零即False
bool ---> int
t = True
print(int(t)) # 1 True --> 1
t = False
print(int(t)) # 0 False --> 0
int ---> str
i1 = 100
print(str(i1)) # '100'
# str ---> int # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1)) # 90
# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1)) # True 非空即True
print(bool(s2)) # False
# bool ---> str
t1 = True
print(str(True)) # 'True'
3.3.2str（字符串）
索引
索引就是下标 组成的元素是从0开始为第一个起始点
a = 'ABCDEFGHIJK'
print(a[0])#打印出A
print(a[3])#打印出D
print(a[5])#打印出F
print(a[7])#打印出H
切片
首先在列表中有一个规则就是顾头不顾尾
什么叫顾头不顾尾 顾名思义就是
a = 'ABCDEFGHIJK'
print[0:4]#输出ABC 顾头不顾腚（尾）
a = 'ABCDEFGHIJK'
print(a[0:3]) # print(a[:3]) 从开头开始取0可以默认不写
print(a[2:5])
print(a[:]) #默认到最后
print(a[:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[:5:2]) #加步长
print(a[-1:-5:-2]) #反向加步长
步长
a = 'ABCDEFGHIJK'
print[-3:-2:-3]
一.数据补充
我们前期的时候和大家说了,有些方法我们放在数据类型补充的这一天中,我们今天将前面没有讲解的内容,都一起讲解了,就先从str开始
str:
以什么开头:
\# s = "ALEX"
\# s1 = s.startswith("E",2,6)
\# print(s1)
以什么结尾:
\# s = "ALEX"
\# s1 = s.endswith("X",3,4)
\# print(s1)
统计
\# s = "alexdxjbx"
\# s1 = s.count("x")
\# print(s1)
1.1 首字母大写
name = "meet"
name.capitalize()
1.2 每个单词的首字母大写
name = "meet"
name.title()
1.3 大小写反转
name = "meet"
name.swapcase()
1.4 统计
name = "meet"
name.count()
1.5 查找
name = "meet"
name.find() # 当查找的时候数据不存在返回-1
name = "meet"
name.index() # 当查找的时候数据不存在报错
1.6 居中
name = "meet"
name.center(20) # 居中一共占用20个位置
1.7 填充
name = "meet{},{},{}"
name1 = name.format("郭宝元","宝帅","宝哥") # 按照位置顺序填充
print(name1)
name = "meet{0},{1},{2}"
name2 = name.format("宝帅","宝哥","郭宝元") # 按照下标填充
print(name2)
name = "meet{a},{c},{b}"
name3 = name.format(a="郭宝元",b="宝帅",c="宝哥") # 按照关键字填充
print(name3)
1.8 拼接 将可迭代容器转换成字符串 字典拼接的是键
可迭代容器中的元素必须是字符串类型
lst = ["2","3","4","5"]
print('*'.join(lst))
tu = ("2","3","4","5")
print('*'.join(tu))
dic = {"key1":2,"key2":4}
print('*'.join(dic))
se = {"1","3","34"}
print('*'.join(se))
字符+
name1 = "alex"
name2 = "wusir"
print(id(name1))
print(id(name2))
print(id(name1 + name2))
字符*
name1 = "alex"
print(id(name1))
print(id(name1 * 5))
字符 + 和 * 都是开辟新的空间
\# print(s.isalnum()) # 判断是不是字母,数字,中文
\# print(s.isalpha()) # 判断是不是字母,中文
\# print(s.isdigit()) # 判断字符串是不是全都是阿拉伯数字
\# print(s.isdecimal()) # 判断是否是十进制
list:
1.1 反转
lst = [1,2,3,4,5]
lst.reverse()
1.2 排序
lst = [1,2,3,4,5]
lst.sort() # 升序
lst.sort(reverse=True) # 降序
1.3 查找
lst = [1,2,3,4,5]
lst.index(3) # 存在就返回索引,不存在就报错
1.4 统计
lst = [1,23,4,5,6,]
lst.count(23) # 统计23出现的次数
list +
lis = [1,2,3]
lst1 = [4,5,6]
print(id(lis))
print(id(lst1))
print(id(lis + lst1))
list *
lst = [1,2,3]
print(lst * 5)
print(id(lst))
print(id(lst * 5))
面试题:
lst = [[]]
new_lst = lst * 5
new_lst[0].append(1)
print(new_lst)
'''
[[1][1][1][1][1]]
'''
列表在进行乘法的时候元素都是共用
tuple:
面试题:
tu = (1) # 获取的括号中元素的本身
tu = (1,2)# 获取的是元组
tu = (1,) # 获取的是元组
列表能够支持+, 元组也可以支持+,
+
tu = (1,2)
tu1 = (3,4)
tu2 = tu + tu1
print(id(tu))
print(id(tu1))
print(id(tu2))
*
tu = ([],)
tu1 = tu * 5
tu1[0].append(9)
print(tu1)
列表在进行乘法的时候元素都是共用
tu = (1,2)
tu1 = tu * 5
print(tu1)
print(id(tu1[0]),id(tu1[-2]))
dict:
[python---创建字典的方式]
- [1、用{}创建字典]
- [2、用内置函数dict()]
- [1)、入参为类似a="1"的键值对]
- [2)、入参为一个元组，元组内部是一系列包含两个值的元组，例如(("a", "1"), ("b", "2"))]
- [3)、入参为一个元组，元组内部是一系列包含两个值的列表，例如(["a", "1"], ["b", "2"])]
- [4)、入参为一个列表，列表内部是一系列包含两个值的元组，例如[("a", "1"),("b", "2")]]
- [5)、入参为一个列表，列表内部是一系列包含两个值的列表，例如[["a", "1"],["b", "2"]]]
- [3、用户fromkeys方法创建字典，第一个]
1、用{}创建字典
代码：
x ={"a":"1", "b":"2"}
print（x）
输出：
{'a': '1', 'b': '2'}
2、用内置函数dict()
1)、入参为类似a="1"的键值对
代码：
x =dict(a="1", b="2")
print (x)
输出：
{'a': '1', 'b': '2'}
2)、入参为一个元组，元组内部是一系列包含两个值的元组，例如(("a", "1"), ("b", "2"))
代码：
x=dict((("a","1"), ("b","2")))
print (x)
输出
{'a': '1', 'b': '2'}
3)、入参为一个元组，元组内部是一系列包含两个值的列表，例如(["a", "1"], ["b", "2"])
代码：
x=dict((["a", "1"], ["b", "2"]))
printx
输出：
{'a': '1', 'b': '2'}
4)、入参为一个列表，列表内部是一系列包含两个值的元组，例如[("a", "1"),("b", "2")]
代码：
x=dict([("a", "1"),("b", "2")])
print x
输出：
{'a': '1', 'b': '2'}
5)、入参为一个列表，列表内部是一系列包含两个值的列表，例如[["a", "1"],["b", "2"]]
代码：
x =dict([["a", "1"],["b", "2"]])
print x
输出：
{'a': '1', 'b': '2'}
注意：
- 对于a="1"的方式初始化字典，字典的key只能为字符串，并且字符串不用加引号
- 对于dict内置函数初始化当入参是一个元组时，例如1)、2)，元组内部的两元素元组或者列表至少为两个，否则会出错
3、用户fromkeys方法创建字典，第一个
代码：
dict.fromkeys(("a","b"),1)
print (x)
输出：
{'a': 1, 'b': 1}
入参可以的第一个参数是一个列表或者元组，里边的值为key，第二个参数是所有key的value值
字典定义方式:
dict(key=1,key1=2,key2=3)
1.1 随机删除
dic = {"key":"value","key2":"value2"}
dic.popitem() # 随机删除
此处说明一下,官方文档中表示是随机删除一个键值对中,但是我们实际测试的时候
都是删除字典中最后的一个键值对,这也是一个Python36中目前存在的一个bug
1.2 批量创建字典
dic = {}
dic1 = dic.fromkeys("abc",[1,2])
print(dic1)
formkeys这个是个坑,坑点就在于值是可变数据类型的时候,当第一个键对应的值进行修改了以后,其余的键对应的值也都跟着进行改变了. 如何避免坑,就是批量创建字典的时候值不能使用可变的数据类型.
set:
集合定义方式:
set("12345")
{1,2,3,4,5} # 将字符串进行迭代添加
最后我们对我们学习的这些数据类型进行一个总结,我们按照有序,无序,可变,不可变,取值方式来总结
- 有序:
- 数字
- 字符串
- 列表
- 元组
- 无序:
- 字典
- 集合
- 可变数据类型:
- 列表
- 字典
- 集合
- 不可变数据类型:
- 字符串
- 数字
- 元组
- 取值顺序:
- 直接取值 — 数字,布尔值,集合
- 顺序取值(索引) — 列表,元组,字符串
- 通过键取值 — 字典
类型转换
元组 => 列表 list(tuple)
列表 => 元组 tuple(list)
列表 => 字符串 ''.join(list)#不能整数 必须是字符串类型的str（）
字符串 => 列表 str.split
转换成False的数据:
0,'',None,[],(),{},set() 都是False
find找不到返回-1
index找不到报错 找到返回索引
is系列
isdigit
isdecimal
isalnum#判断是不是 字母 数字汉字
isalpha
公共方法
len()
列表list
列表是一个可迭代对象
用法：你需要存储大量的数据，且需要这些数据有序的时候。制定一些特殊的数据群体：按顺序，按规则，自定制设计数据
增
1.append直接添加#追加(在列表的最后位置添加一个内容)
2.expend迭代添加
3.lst.insert(2,"wusir") #插入 以后尽量不要使用(当数据量比较大的时候会影响效率
删
del
remove
clear
改
索引，切片进行修改
lst = ["太白", "太黑", "五色", "银王", "⽇天"]
lst[1] = "太污" # 把1号元素修改成太污 print(lst)
lst[1:4:3] = ["麻花藤", "哇靠"] # 切片修改也OK. 如果步长不是1, 要注意元素的数
print(lst)
lst[1:4] = ["我是哪个村的村长王富贵"] # 如果切片没有步长或者步长是1. 则不用关心个数
print(lst)
a=list(1,3,4)
print(a)
查
索引查询
列表是一个可迭代对象，可以进行for循环
列表的嵌套
lst = [1,'太白','wusir',['麻花疼',['可口可乐'],'王健林']]
3.2.4列表的方法
len
index 返回索引 找不到报错
sort排序
reverse反转
4.元组tuple
是不可变类型
是一个特殊的列表不能增加不能删除只能查看
元组的方法
长度len()
len()
三.其他（for，enumerate，range）。
for循环：用户按照顺序循环可迭代对象的内容。
msg = '老男孩python是全国范围内最好的python培训机构'
for item in msg:
print(item)
li = ['alex','银角','女神','egon','太白']
for i in li:
print(i)
dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
print(k,v)
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
range：指定范围，生成指定数字。
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步长
print(i)
for i in range(10,1,-2): # 反向步长
print(i)
l1 = ['wusir', 'alex', '太白', '女神', 12, 666]
for i in range(len(l1)):
print(i)
