数据类型

第三章 基础

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 "[e-mail]"

创建 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"``]))``print` `x`

输出：

{'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()