python的基本类型有哪些_Python 基础数据类型

Python基本数据类型

1.说一下基本数据类型有哪些

整型(int)

作用：

记录年龄、身份证号、个数等等

定义：

age = 18

浮点型(float)

作用：

记录薪资、身高、体重

定义:

salary = 3.3

height = 1.87

weight = 70.3

字符串类型(str)

作用：

记录描述性质的状态，名字、一段话

定义：

用引号(''，""，''' '''，""" """，)包含的一串字符

如：name = 'xxq'

列表(list)

作用：

按位置记录多个值(同一个人的多个爱好、同一个班级的所有学校姓名、同一个人12个月的薪资)

并且可以按照索引取指定位置的值

定义：

在[]内用逗号分隔开多个任意类型的值,一个值称之为一个元素

如：list1 = [1,2,3,4,'5','六']

注意点：

索引对应值，索引从0开始，0代表第一个

字典(dic)

作用：

用来存多个值，每个值都有唯一一个key与其对应，key对值有描述性功能

定义：

在{}内用逗号分开各多个 key：value

如：info={"name":'xxq',"age":18, "gender":'male'}

布尔类型(bool)

作用：

用来记录真假这两种状态

定义：

is_ok = True

is_ok = False

其他使用：

通常用来当作判断的条件，我们将在if判断中用到它

元组类型(tuple)

作用：

按照索引/位置存放多个值，只用于读，不用于改

定义：

t = (1,1.3,'aaa')

注意点：

1.单独一个括号，代表包含的意思

x = (10)

2.如果元组中只有一个元素，必须加逗号

x = (10,)

3.元组不能改，指的是不能改里面的内存地址

t = (1,[11,22])

print(t,id(t[0]),id(t[1]))

t[1][0] = 33 # 元组内的列表的元素还是可以改的

print(t,id(t[0]),id(t[1]))

(1, [11, 22]) 2038884272 59297864

(1, [33, 22]) 2038884272 59297864

集合类型(set)

作用：

关系运算、去重

定义：

在 {} 内通逗号隔开多个元素，多个元素满足以下条件：

1.集合内的元素必须为不可变类型

2.集合内的元素无序

3.集合内的元素没有重复

2.说一下交互

什么是交互？

交互就是人和计算机互动，人输入信息，计算机获取后，输出信息给人，循环往复的这个过程，就是交互。

为什么要交互？

为了让计算机可以和人一样沟通，要操控计算机就是通过这种可以交互的性质。

怎么交互？

输入 和 输出

3.说一下运算符

算数运算符

包括：+、-、*、/、//、%、**

# print(10 + 3.1)

# print(10 + 3)

# print(10 / 3) # 结果带小数

# print(10 // 3) # 只保留整数部分

# print(10 % 3) # 取模、取余数

# print(10 ** 3) # 取模、取余数

比较运算符

包括：>、>=、

# print(10 > 3)

# print(10 == 10)

#

# print(10 >= 10)

# print(10 >= 3)

# name=input('your name: ')

# print(name == 'egon')

赋值运算符

1.变量的赋值：=

2.增量赋值

# age = 18

# # age += 1 # age=age + 1

# # print(age)

#

# age*=3

# age/=3

# age%=3

# age**=3 # age=age**3

3.链式赋值

# x=10

# y=x

# z=y

# z = y = x = 10 # 链式赋值

# print(x, y, z)

# print(id(x), id(y), id(z))

4.交叉赋值

m=10

n=20

# print(m,n)

# 交换值

# temp=m

# m=n

# n=temp

# print(m,n)

# m,n=n,m # 交叉赋值

# print(m,n)

5.解压赋值

# 把五个月的工资取出来分别赋值给不同的变量名

# mon0=salaries[0]

# mon1=salaries[1]

# mon2=salaries[2]

# mon3=salaries[3]

# mon4=salaries[4]

# 解压赋值

# mon0,mon1,mon2,mon3,mon4=salaries

# print(mon0)

# print(mon1)

# print(mon2)

# print(mon3)

# print(mon4)

# mon0,mon1,mon2,mon3=salaries # 对应的变量名少一个不行

# mon0,mon1,mon2,mon3,mon4,mon5=salaries # 对应的变量名多一个也不行

4.可变不可变类型的区别

可变类型：

值改变，id不变，证明改的是原值，证明原值是可以被改变的

不可变类型：

值改变，id也改变了，证明是产生新的值，压根没有改变原值，证明原值是不可改变的

5.基本数据类型 总结

按照存值个数区分

只能存一个值(可称为标量/量子类型)： 数字、字符串

可以存放多个值(可称为容器类型)： 列表、元组、字典

按照访问方式区分

只能存一个值(可称为标量/量子类型)： 数字

可以存放多个值(可以用索引访问指定的值，又称为序列类型)： 字符串、列表、元组

key访问(可以用key访问指定的值，又称为映射类型)： 字典

按照可变不可变区分

可变类型： 列表、字典

不可变类型： 数字、字符串、元组

6.简单描述定义一个变量x=10，在内存的栈区和堆区的存放情况

栈区 存放变量名 x

堆区 存放变量值 10

7.简述一下 直接引用 和 间接引用

直接引用：

直接把值传给变量名，如：

x = 10

print(x)

间接引用：

把值传给一个变量后，间接把值传给另一个变量

x = 10

y = x

print(y)

8.接收用户输入的：用户名、年龄、性别，然后选取最优格式化字符串的方式，按照如下格式输出：

我的名字是：XXX

我的年龄是：XXX

我的性别是：XXX

name = input('请输入姓名：')

age = input('请输入年龄：')

gender = input('请输入性别：')

info = '''

我的名字是：{name}

我的年龄是：{age}

我的性别是：{gender}

'''.format(name=name, age=age, gender=gender)

print(info)

9.用算数运算符演示：取模运算、增量运算、交叉赋值、链式赋值、解压赋值

# 取模(取余数)运算：

print(10 % 3)

# 增量运算：

x = 10

x += 1

print(x)

# 交叉赋值：

a = 1

b = 2

a, b = b, a

print(a, b)

# 链式赋值：

x = y = z = 1

print(x, y, z)

# 解压赋值：

s = [1, 2, 3]

m1, m2, m3 = s

print(m1, m2, m3)

10.写一段用户登录的代码：

要求：

1.用户输错3次，退出程序，并提示输错次数过多

2.用户输入正确，则进入子程序，开始循环执行命令

3.在循环内，用户输入退出命令，则退出所有循环

username = 'xxq'

password = '123'

count = 0

while count < 3:

inp_username = input('请输入账号：')

inp_password = input('请输入密码：')

if username == inp_username and password == inp_password:

print('登录成功！')

while True:

inp_cmd = input('请输入指令：(按‘q’退出程序)')

if inp_cmd == 'q':

print('接收到退出指令，程序退出！')

break

else:

print('指令', inp_cmd, '正在执行，按‘q’退出程序')

break

else:

print('账号或面错误，请重试！')

count += 1

else:

print('输错3次了，自动退出程序！')

11.集合内元素的3个特征

1.集合内的元素 必须为 不可变类型(数字、字符串、元组)

2.集合内的元素 无序

3.集合内的元素 没有重读

12.集合的用途是什么？

去重(如：列表去重)

关系测试(如：取交集、取并集、取差集等)

13.举例说明关系运算(交集、并集、差集、对称差集、父子集)

① 取出交集：两者共同的好友( & / .intersection() )

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们

res = friends1 & friends2

res = friends1.intersection(friends2)

print(res)

{'egon', 'jason'}

② 取出并集/交集：两者所有的好友( | / .union() )

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们

res = friends1 | friends2

res = friends1.union(friends2)

print(res)

{'egon', 'kevin', 'ricky', 'Jy', 'zero', 'jason'}

③ 取出差集：取出其中一个集合独有的好友( - / .difference() )

取出 friends1 独有的好友：

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们

res = friends1 - friends2

res = friends1.difference(friends2)

print(res)

{'kevin', 'zero'}

取出 friends2 独有的好友：

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们

res = friends2 - friends1

res = friends1.symmetric_difference(friends2)

print(res)

{'ricky', 'Jy'}

④ 对称差集：求2个用户独有的好友们(即：去掉共同的好友)( ^ )

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们

res = friends2 ^ friends1

print(res)

{'kevin', 'Jy', 'ricky', 'zero'}

⑤ 父子集：包含的关系( < / = / > / .issubset() )

s1 = {1,2,3}

s2 = {1,2,4}

# 不存在包含关系，下面比较均为False

print(s1.issupersets2())

print(s1 > s2)

print(s1 < s2)

s1 = {1,2,3}

s2 = {1,2}

print(s1.issubset(s2))

print(s1 > s2) # 当s1大于或等于s2时，才能说s1是s2的爹

s1={1,2,3}

s2={1,2,3}

print(s1 == s2) # s1与s2互为父子

14.基于集合对列表去重l1 = [1, 1, 1, 1, 1, 1, 2, 3, 3, 'a']

l1 = [1, 1, 1, 1, 1, 1, 2, 3, 3, 'a']

print(set(l1))

15.简述一下集合去重的局限性

1.只能针对不可变类型去重

2.无法保证原来的顺序