二、Python3 基本数据类型

一、数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）　　       使用单引号、双引号、三引号数据类型为字符串类型

>>> '''
... hello world
... hollo world
... hollo world
... '''
'\nhello world\nhollo world\nhollo world\n'

>>> "let's go"
"let's go"
>>> 'let"s go'
'let"s go'

• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）
• 

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）；

其他类型

bool布尔值类型：真（True）、假（False）

>>> int(True)
1
>>> int(False)
0
>>> bool(1)
True
>>> bool(0)
False

注：

除数字0为False，其他数字为True

空的列表、字符串、元组，在判断布尔值时都是为False，例如bool({})、bool(None)

complex 复数

>>> 78j
78j

代码段

# tpye方法用来查询字符类型
print("tpye方法用来查询字符类型;",type(1*1))

# 输出浮点数
print("单斜杠会转成浮点数;",type(2/2))

# 输出整数
print(type(2//2))
print("保留为整数;",type(1//2))

输出结果

tpye方法用来查询字符类型; 
单斜杠会转成浮点数; 

保留为整数;

二、各进制的表示与转换

代码段

# 二进制表达方法，前面需要加上0b
0b10
print("二进制表达方法，前面需要加上0b:",0b10)
# 八进制表达方法，前面需要加上0o
0o11
print("八进制表达方法，前面需要加上0o:",0o11)
# 十六进制表达方法，前面需要加上0x
0x10
print("十六进制表达方法，前面需要加上0x:",0x10)


# 将十进制转换成二进制
bin(10)
print("将十进制转换成二进制:",bin(10))
# 将八进制转换成二进制
bin(0o11)
print("将八进制转换成二进制:",bin(0o11))
# 将十六进制转换成二进制
bin(0xE)
print("将十六进制转换成二进制:",bin(0xE))


# 将二进制转换成八进制
oct(0b111)
print("将二进制转换成八进制:",oct(0b111))

# 将二进制转换成十进制
int(0b111)
print("将二进制转换成十进制:",int(0b111))

# 将十进制转换成十六进制
hex(888)
print("将十进制转换成十六进制:",hex(888))

输出结果

二进制表达方法，前面需要加上0b: 2
八进制表达方法，前面需要加上0o: 9
十六进制表达方法，前面需要加上0x: 16
将十进制转换成二进制: 0b1010
将八进制转换成二进制: 0b1001
将十六进制转换成二进制: 0b1110
将二进制转换成八进制: 0o7
将二进制转换成十进制: 7
将十进制转换成十六进制: 0x378

三、转义字符

\n换行

\' 单引号

\t 横向制表符

注：

如想打印转义字符，只需在前面增加一个斜杠，例如print("hello\\nworld")，打印结果为hello\nworld

在需要打印的字符串加上r，也可以打印转义字符，例如print(r"c:\network\ntc")，打印结果为c:\network\ntc的原始字符串

四、列表list

1、切片查询

注：第三个参数为步长，正数从左往右取，负数从右往左取

# 新建一个列表
a=['zhangsan','lisi','wangwu','zhaoliu','sunqi',['wangwu','qianba']]
 
# 切片查询
print('取到最后一个：',a[1:])
print('取到倒数第二值：',a[1:-1])
print("从左到右一个一个去取：",a[1:-1:2])  # 最后一个属于步长
print('从左到右隔一个取一个：',a[1::2])
print('从第四个从右到左取',a[3::-1])

结果

取到最后一个： ['lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
取到倒数第二值： ['lisi', 'wangwu', 'zhaoliu', 'sunqi']
从左到右一个一个去取： ['lisi', 'zhaoliu']
从左到右隔一个取一个： ['lisi', 'zhaoliu', ['wangwu', 'qianba']]
从第四个从右到左取 ['zhaoliu', 'wangwu', 'lisi', 'zhangsan']

注：如果切片加上冒号，返回的是一个列表，不加冒号，返回字符串

print(['新月打击','苍白之瀑','月之降临','月神冲刺'][0])
print(['新月打击','苍白之瀑','月之降临','月神冲刺'][0:])

结果

新月打击
['新月打击', '苍白之瀑', '月之降临', '月神冲刺']

2、列表运算

列表相加、相乘

print(['新月打击','苍白之瀑']+['月之降临','月神冲刺'])
print(['点燃','闪现']*3)

结果

['新月打击', '苍白之瀑', '月之降临', '月神冲刺']
['点燃', '闪现', '点燃', '闪现', '点燃', '闪现']

列表判断

# 判断列表中是否存在某一数据
print(3 in [1,2,3,5])
# 判断列表中是否不存在某一数据
print(3 not in [1,2,3,5])

结果

True
False

3、添加append insert

# 添加 append insert
a = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
a.append('xuepeng') #默认插到最后一个位置
print(a)
a.insert(1,'xuepeng') #将数据插入到任意一个位置
print(a)

结果

['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba'], 'xuepeng']
['zhangsan', 'xuepeng', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba'], 'xuepeng']

4、修改

a = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
a[1]='xiaohong'
print(a)
a[1:3]=['a','b'] # 切片修改
print(a)

结果

['zhangsan', 'xiaohong', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
['zhangsan', 'a', 'b', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]

5、删除 remove pop del

a = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
a.remove(a[0])   # 删除列表中第一个字符串
print(a)

结果

['lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]

删除嵌套列表中的数据

a = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
a.remove(['wangwu','qianba']) # 删除嵌套列表中的数据
print(a)

结果

['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi']

删除指定字符串后，并将删除的字符串返回

a = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
b=a.pop(1)   # 删除指定字符串后，并将删除的字符串返回
print(a)
print(b)

结果

['zhangsan', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
lisi

通过索引删除

a = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]
del a[0]  # 通过索引删除
print(a)
del a     # 删除整个列表

结果

['lisi', 'wangwu', 'zhaoliu', 'sunqi', ['wangwu', 'qianba']]

6、count:计算某元素出现次数

t=['to', 'be', 'or', 'not', 'to', 'be'].count('to')
print(t)

结果

2

7、extend：合并列表

a = [1, 2, 3]
b = [7, 5, 6]
a.extend(b)     # 将b列表的数据，合并到a列表中
print(a)
print(b)

结果

[1, 2, 3, 7, 5, 6]
[7, 5, 6]

8、index：根据内容找位置

a = ['zhangsan','lisi','wangwu','zhaoliu','sunqi','lisi',['wangwu','qianba']]
weizhi = a.index("wangwu")
print("sunqi的索引位置是:",weizhi)
print('取出索引号+1位置后面所有的数据：',a[weizhi+1:])
b = a[weizhi+1:]
print('查找sunqi的位置：',b.index('sunqi'))  #
c = weizhi + b.index('sunqi')+1    # 2+1+1
print(c)
print(a[c])

结果

sunqi的索引位置是: 2
取出索引号+1位置后面所有的数据： ['zhaoliu', 'sunqi', 'lisi', ['wangwu', 'qianba']]
查找sunqi的位置： 1
4
sunqi

9、排序：reverse sort

a = ['zhangsan','lisi','wangwu','zhaoliu','sunqi','lisi',['wangwu','qianba']]
a.reverse()  #反过来排序
print(a)

x = [4, 6, 2, 1, 7, 9]
x.sort()        #升序
print(x)#[1, 2, 4, 6, 7, 9]
x.sort(reverse= True)  #降序
print(x)

结果

[['wangwu', 'qianba'], 'lisi', 'sunqi', 'zhaoliu', 'wangwu', 'lisi', 'zhangsan']
[1, 2, 4, 6, 7, 9]
[9, 7, 6, 4, 2, 1]

五、元组tuple

生成一个元组的两种方法

# 使用()赋值
tuple1 = (1,2,3,4)
print(tuple1)
# 使用tuple关键字赋值
tuple2 = tuple(('xiaoming','zhangsan','lisi'))
print(tuple2)

结果

1, 2, 3, 4)
('xiaoming', 'zhangsan', 'lisi')

通过切片访问，注意：创建一个元素的元组时，必须带有逗号

tuple1 = (1,)
print(tuple1[0])

结果

1

使用推导式生成并访问元组对象

# 使用推导式生成并访问元组对象
tuple1 = (i for i in range(1,11))
print(tuple1)
# 遍历一个元组
for x in tuple1:
    print(x)

结果

at 0x105f79d20>
1
2
3
4
5
6
7
8
9
10

六、元组和列表的区别

列表是可变的，而元组是不可变的，这标志着两者之间的关键差异

我们可以修改列表的值，但是不修改元组的值

列表是动态的，长度大小不固定，可随意的增加、删除、修改元素

元组的静态的，长度在初始化的时候就已经确定不能更改，更无法增加、删除、修改元素

由于列表是可变的，我们不能将列表用做字典中的key。但是可以使用元组作为字典key

七、字符串str

1、str操作

stra = "joy....ll...."

print("重复输入10个字符串：",stra*10)

print("通过切片的方式获取字符串：","helloworld"[2:6])

结果

重复输入10个字符串： joy....ll....joy....ll....joy....ll....joy....ll....joy....ll....joy....ll....joy....ll....joy....ll....joy....ll....joy....ll....
通过切片的方式获取字符串： llow

2、关键字 in

print("查看列表中是否包含123：",123 in [23,45,123])

x = "hello"
print("e2是否包含在hello里面：",'e2' in x)

结果

查看列表中是否包含123： True
e2是否包含在hello里面： False

3、字符串方法 格式化输出、字符串拼接 join

print("格式化输出：",'%s is a good teacher'%'joy')

a = '123'
b = 'abc'
c = a+b
print("a+b字符串拼接：",c)

d = '44'
c = ''.join([a,b,d])
print("join方法拼接：",c)

结果

格式化输出： joy is a good teacher
a+b字符串拼接： 123abc
join方法拼接： 123abc44

4、字符串方法 查、改、增、判断

查 count find index rfind

st='hello kitty {name} is {age}'
print("统计元素出现个数：",st.count('l'))
print("查找到第一个元素，并将索引值返回：",st.find('t'))
print("查找到第一个元素的索引值：",st.index('t'))
print("从右到左，打印字符最后一次出现的位置：",'My title title'.rfind('t'))

结果

统计元素出现个数： 2
查找到第一个元素，并将索引值返回： 8
查找到第一个元素的索引值： 8
从右到左，打印字符最后一次出现的位置： 11

5、改 capitalize format format_map lower upper swapcase strip lstrip rstrip replace split title

st='hello kitty {name} is {age}'

print("修改首字母大写：",st.capitalize())

print("格式化输出的另一种方式：",st.format(name='joy',age=28))

print("使用字典的方式格式化输出：",st.format_map({'name':'hebe','age':34}))

print("将大写字母变为小写：",'My tLtle'.lower())

print("将小写字母变为大写：",'My tLtle'.upper())

print("将大小写字母进行转换：",'My tLtle'.swapcase())

print("用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列：",'\tMy tLtle\n'.strip())

print("用于截掉字符串左边的空格或指定字符：",'\tMy tLtle\n'.lstrip())

print("用于截掉字符串右边的空格或指定字符：",'\tMy tLtle\n'.rstrip())

print("将原有字符替换成新字符，后面加替换个数：",'My title title'.replace('itle','lesson',1))

print("以i为分割符，分割1次：",'My title title'.split('i',1))

print("将字符串，转换成标题格式（即每个单词的首字母为大写）：",'My title title'.title())

结果

修改首字母大写： Hello kitty {name} is {age}
格式化输出的另一种方式： hello kitty joy is 28
使用字典的方式格式化输出： hello kitty hebe is 34
将大写字母变为小写： my tltle
将小写字母变为大写： MY TLTLE
将大小写字母进行转换： mY TlTLE
用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列： My tLtle
用于截掉字符串左边的空格或指定字符： My tLtle

用于截掉字符串右边的空格或指定字符：    My tLtle
将原有字符替换成新字符，后面加替换个数： My tlesson title
以i为分割符，分割1次： ['My t', 'tle title']
将字符串，转换成标题格式（即每个单词的首字母为大写）： My Title Title

6、增 center expandtabs ljust rjust

st = 'hello kitty {name} is {age}'
print("打印包含#的50个字符串，居中格式化输出：",st.center(50,'#'))

sta = 'a(\t)'
print("符号t默认的空格数是 10：",sta.expandtabs(tabsize=10))
print("原字符串左对齐，打印50个字符，多余的用*填充：",'My tLtle'.ljust(50,'*'))
print("原字符串右对齐，打印50个字符，多余的用*填充：",'My tLtle'.rjust(50,'*'))

结果

打印包含#的50个字符串，居中格式化输出： ###########hello kitty {name} is {age}############
符号t默认的空格数是 10： a(        )
原字符串左对齐，打印50个字符，多余的用*填充： My tLtle******************************************
原字符串右对齐，打印50个字符，多余的用*填充： ******************************************My tLtle

7、判断 布尔值 endswith startswith isalnum isdecimal isnumeric isidentifier islower isupper isspace istitle

st='hello kitty {name} is {age}'

print("判断是否以某个内容结尾,返回值True/False：",st.endswith('e}'))

print("判断是否以某个内容开头,返回值True/False：",st.startswith('he'))

print("判断字符中是否存在字母和数字：",'as1'.isalnum())

print("判断字符中是否存在数字：",'12632178'.isdecimal())

print("判断字符串中是否所有的都是数字：",'1269999aa'.isnumeric())

print("可用来判断变量名是否合法：",'abc'.isidentifier())

print("判断是否为全部小写字母：",'Aab'.islower())

print("判断是否为全部大写字母：",'ABC'.isupper())

print("判断是否为全部空格字符：",'   '.isspace())

print("判断是否所有单词首字母为大写：",'My title'.istitle())

结果

判断是否以某个内容结尾,返回值True/False： True
判断是否以某个内容开头,返回值True/False： True
判断字符中是否存在字母和数字： True
判断字符中是否存在数字： True
判断字符串中是否所有的都是数字： False
可用来判断变量名是否合法： True
判断是否为全部小写字母： False
判断是否为全部大写字母： True
判断是否为全部空格字符： True
判断是否所有单词首字母为大写： False

8、常用方法

st='hello kitty {name} is {age}'

print(st.count('l'))

print(st.center(50,'#'))   #  居中

print(st.startswith('he')) #  判断是否以某个内容开头

print(st.find('t'))

print(st.format(name='alex',age=37))  # 格式化输出的另一种方式   待定：?:{}

print('My tLtle'.lower())

print('My tLtle'.upper())

print('\tMy tLtle\n'.strip())

print('My title title'.replace('itle','lesson',1))

print('My title title'.split('i',1))

结果

2
###########hello kitty {name} is {age}############
True
8
hello kitty alex is 37
my tltle
MY TLTLE
My tLtle
My tlesson title
['My t', 'tle title']

八、集合set

1、创建一个集合

# 集合表示方式使用花括号
aset = {1,2,3,4,5,6}     # 创建一个集合
print(type(aset))
print("使用关键字set定义集合",type(set()))

结果

使用关键字set定义集合

2、集合的特性

无序，不可以使用切片

不重复，{1,2,2,3}执行结果为{1,2,3}

3、set的操作

# 查看有多少个元素
print(len({1,2,3,4,5,6,6}))
print('元素是否包含在集合中:',1 in {1,2,3})
print('元素是否不包含在集合中:',1 not in {1,2,3})

结果

6
元素是否包含在集合中: True
元素是否不包含在集合中: False

4、差集、交集、并集

aset1 = {1,2,3,4,5,6}
aset2 = {5,4}
aset3 = {3,4,7}
print("求两个集合的差集",aset1 - aset2)
print("求两个集合的交集",aset1 & aset2)
print("求两个集合的并集",aset1 | aset3)

结果

两个集合的差集 {1, 2, 3, 6}
求两个集合的交集 {4, 5}
求两个集合的并集 {1, 2, 3, 4, 5, 6, 7}

九、字典dict

1、什么是字典

字典是python里的一种数据类型，特点是元素的无序性，和键key的唯一性。字典的创建方法是{key：values}，字典里的键key只能是不可变的数据类型（整型，字符串或者是元组），值values可以是任何数据类型。字典里的一组key：values叫做一个键值对item。

2、创建字典

dic = {'name':'joy','age':'28','hobby':{'girl_name':'xiaohan','age':23},'is_handsome':True}
# 另外一种创建方式，通过关键字创建 dict
dic2 = dict((('name','joy'),))
print("元组的方式创建字典：",dic2)
dic3 = dict([['name','joy'],])
print("列表的方式创建字典：",dic3)

结果

元组的方式创建字典： {'name': 'joy'}
列表的方式创建字典： {'name': 'joy'}

3、特性

字典中的key是不可变类型，例如key不可以是列表

字典中的value可以是任意数据类型

4、查看字典 keys、values、items

dic = {'name':'chenzhang','age':27}

dic1 = dic['age']     #

print("通过键去取值：",dic1)

dic5 = {'age':18,'name':'joy','hobby':'boy'}

print("通过键去取值：",dic5['hobby'])

dic6 = {'age':18,'name':'joy','hobby':'boy'}

print("使用列表的格式，查看字典的键：",list(dic6.keys()))

print("使用列表的格式，查看字典的值：",list(dic6.values()))

print("用列表的格式，查看字典的键值对：",list(dic6.items()))

结果

通过键去取值： 27
通过键去取值： boy
使用列表的格式，查看字典的键： ['age', 'name', 'hobby']
使用列表的格式，查看字典的值： [18, 'joy', 'boy']
用列表的格式，查看字典的键值对： [('age', 18), ('name', 'joy'), ('hobby', 'boy')]

5、新增键值对 setdefault 

dic4 = {'name':'joy'}
dic4['age'] = 18
print("新增键值对：",dic4)

ret = dic4.setdefault('age',32)
print("如果键存在，不修改键值对,返回原有值：",ret)

ret = dic4.setdefault('shengao',168)
print("如果键不存在，新增键值对：",dic4)

结果

新增键值对： {'name': 'joy', 'age': 18}
如果键存在，不修改键值对,返回原有值： 18
如果键不存在，新增键值对： {'name': 'joy', 'age': 18, 'shengao': 168}

6、修改字典 fromkeys

dic7 = {'name':'陈璋','age':'23','hobby':'girl'}
dic7['age'] = 27                # 通过键去修改值
print("通过键去修改值：",dic7)

dic13=dict.fromkeys(['host1','host2','host3'],'test')
print("使用formkeys方法，给每一键加上（test）值：",dic13)

dict14= dict.fromkeys(['host1','host2','host3'],['test1','test2'])
print("使用formkeys方法，给每一键加上（列表）值：",dict14)

dict14['host2'][1]= 'test3'
print("改字典中host2中test2的值：",dict14)

结果

通过键去修改值： {'name': '陈璋', 'age': 27, 'hobby': 'girl'}
使用formkeys方法，给每一键加上（test）值： {'host1': 'test', 'host2': 'test', 'host3': 'test'}
使用formkeys方法，给每一键加上（列表）值： {'host1': ['test1', 'test2'], 'host2': ['test1', 'test2'], 'host3': ['test1', 'test2']}
改字典中host2中test2的值： {'host1': ['test1', 'test3'], 'host2': ['test1', 'test3'], 'host3': ['test1', 'test3']}

7、更新 update

dic8 = {'age':18,'name':'joy','hobby':'girl'}
dic9 = {'shengao':180,'name':'joychen'}
dic8.update(dic9)
print("更新，修改已有的键值对，增加没有的键值对：",dic8)

结果

更新，修改已有的键值对，增加没有的键值对： {'age': 18, 'name': 'joychen', 'hobby': 'girl', 'shengao': 180}

8、删除 clear pop popitem del

dic10 = {'name':'joychen','age':18,'class':1}
dic10.clear()
print("清空字典：",dic10)

dic12 = {'name':'joychen','age':18,'class':1}
ret = dic12.pop('age')
print("删除字典中指定键值对，并返回该键值对的值：",ret)
print("删除后的结果：",dic12)

dic13 = {'name':'joychen','age':18,'class':1}
a = dic13.popitem()
print("随机删除某组键值对，并以元组方式返回值：",a)
print("删除后的结果：",dic13)

del dic13  # 删除这个字典

结果

清空字典： {}
删除字典中指定键值对，并返回该键值对的值： 18
删除后的结果： {'name': 'joychen', 'class': 1}
随机删除某组键值对，并以元组方式返回值： ('class', 1)
删除后的结果： {'name': 'joychen', 'age': 18}

9、多层嵌套大字典查询

class_dict = {"蔬菜":{"苦瓜":["很苦","有降火功效"],
                     "南瓜":["比较甜","个头也比较大"],},
               "水果":{"西瓜":["很甜","形状是圆的"],
                     "橘子":["清甜可口","包含多种维生素"]},
               "电器":{"空调":["凉爽","耗电"],
                     "洗衣机":["快速洗衣","节省时间"],
                     "微波炉":["快速加热","方便快捷"]},
               "交通":{"自行车":["上坡费劲","适合短程"],
                     "摩托车":["速度快","不安全"],
                     "汽车":["适应多种天气","价格昂贵"]}
               }
aa = class_dict["交通"]["摩托车"][1]  #能过键去找值，最后通过索引号找到对应的信息
print(aa)

结果

不安全