1、基本数据类型
在我们的之前篇day02-变量中，我们介绍了变量及变量的赋值，我们都知道变量是存储在内存中的值，其实在内存中是会根据变量的数据类型，来分配指定的内存空间，那这变量的数据类型有哪些呢？ Python的基本数据类型一般分为6种：- Numbers（数值）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
- Set（集合）
name = "Ali" # 字符串类型，存储姓名
age = 25 # 整数类型，存储年龄
height = 1.65 # 浮点数类型，存储身高
is_student = True # 布尔类型，存储是否是学生
hobbies = ['reading', 'painting', ] # 列表类型，存储爱好
address = {'street': '123 Main St', 'city': 'China',} # 字典类型，存储地址信息
2、Numbers数字
数字支持四种数字类型：- int（整型）
- float（浮点型）
- bool（布尔型）
- complex（复数）
age = 25 # 年龄 temperature = 37.5 # 温度 is_student = True # 是否是学生 z1 = 2 + 3j # 复数1，实部为2，虚部为3 print(type(age)) print(type(temperature)) print(type(is_student)) print(type(z1)) # 输出结果 <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>在一些混合计算中，Python会把int类型转换为float类型，而在上篇的运算符中，
/运算符结果总会返回浮点数，而//运算符会返回整数
那为什么说数字类型是不可变数据类型呢？
x = 5 print(x, id(x)) # 输出: 5 140709922068256 x = 10 # 修改了x的值 print(x, id(x)) # 输出: 10 140709922068416上述x=5，我们知道是x的这个变量指向了整数5的内存地址，然后我们修改了x的值为10，其实会新创建一个整数10，然后x指向整数10的变量，但是整数5的对象还在，只是不在指向，从id值中也可看出整数是不可变的数据类型
3、String字符串
字符串(String)是由数字、字母、下划线组成的一串字符。 一般可以记：a = "数字字母下划线之类的"它可以表示文本的数据类型 字符串下标 我们定义变量为字符串后，可以对字符串进行取值，那就需要用到下标。可以使用
tips：获取的新字符串可以拿到头下标的值，而拿不到尾下标的值字符串可以使用
+拼接，可以使用*重复操作
下边简单练习让你更深一步理解字符串下标
s = 'Hello Python!' print(s) # 输出完整字符串 print(s[0]) # 输出字符串中的第一个字符 print(s[2:5]) # 输出字符串中第三个至第六个之间的字符串 print(s[2:]) # 输出从第三个字符开始的字符串 print(s[:-1]) # 输出字符串中最后一个字符串之前的所有字符串(不包括最后一个字符串)) print(s[-3:-1]) # 输出从倒数第三个开始至倒数第二个元素 print(s * 2) # 输出字符串两次 print(s + " 我要学会你 ") # 输出连接的字符串 # 输出结果 Hello Python! H llo llo Python! Hello Python on Hello Python!Hello Python! Hello Python! 我要学会你
4、List列表
List（列表） 是 Python 中使用最频繁的数据类型。 列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。 列表用[]标识，是 python 最通用的复合数据类型。
一般可以记：
a = "字符，数字，字符串甚至可以包含列表"列表下标 列表下标与字符串下标同样用到变量 头下标:尾下标 ，就可以截取相应的列表 从左到右索引默认 0 开始，从右到左索引默认 -1 开始。如下图：
+拼接，可以使用*重复操作
下边简单练习让你更深一步理解列表下标
li = ['1', 2, 3.14, '哈哈', 5555] li_2 = [1, 2, 3] print(li) # 输出完整列表 print(li[0]) # 输出列表的第一个元素 print(li[1:3]) # 输出第二个至第三个元素 print(li[2:]) # 输出从第三个开始至列表末尾的所有元素 print(li[:3]) # 输出从第一个开始至第三个元素 print(li[-3:-1]) # 输出从倒数第三个开始至倒数第二个元素 print(li * 2) # 输出列表两次 print(li + li_2) # 打印组合的列表 # 输出结果 ['1', 2, 3.14, '哈哈', 5555] 1 [2, 3.14] [3.14, '哈哈', 5555] ['1', 2, 3.14] [3.14, '哈哈'] ['1', 2, 3.14, '哈哈', 5555, '1', 2, 3.14, '哈哈', 5555] ['1', 2, 3.14, '哈哈', 5555, 1, 2, 3]
5、Tuple元祖
元组是另一个数据类型，类似于 List（列表） 元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
同样的，元祖也是使用的下标，+拼接，可以使用*重复操作
下边简单练习让你更深一步理解元祖下标
tup = ('111d', 222, 333, '4444d', 5555)
tup_2 = (123, 'show')
print(tup) # 输出完整元组
print(tup[0]) # 输出元组的第一个元素
print(tup[1:3]) # 输出第二个至第四个（不包含）的元素
print(tup[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tup * 2) # 输出元组两次
print(tup + tup_2) # 打印组合的元组
# 输出结果
('111d', 222, 333, '4444d', 5555)
111d
(222, 333)
(333, '4444d', 5555)
('111d', 222, 333, '4444d', 5555, '111d', 222, 333, '4444d', 5555)
('111d', 222, 333, '4444d', 5555, 123, 'show')
列表和元祖的不同
列表（list）是可变的数据类型，而元组（tuple）是不可变的数据类型。意思是列表可以添加元素、修改元素和删除元素。而元祖不可添加元素、修改元素和删除元素。
my_list = [1, 2, 3] my_tuple = (1, 2, 3) # 修改值 my_list[1] = 5 my_tuple[1] = 5 # 添加值 my_list.append(4) my_tuple.append(4) # 删除值 del my_list[0] del my_tuple[0]运行下看下结果吧
6、Dict字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。 列表是有序的对象集合，字典是无序的对象集合。 两者之间的区别在于：列表可以通过下标索引来存取，而字典通过key索引来存取 字典用{}标识。字典是一个个键值对key-value组成
my_dict = {'Name': 'hua', 'Age': 7, 'sex': '男'}
# 打印字典
print(my_dict)
print(my_dict['Name']) # 输出键为'Name'的值
print(my_dict['Age']) # 输出键为'Age'的值
# 查看字典的数量
print(len(my_dict))
# 查看类型
print(type(my_dict))
# 修改字典中的值
my_dict['Age'] = 8
print(my_dict['Age'])
# 删除字典中的键
del my_dict['Age']
print(my_dict)
# 输出所有键
print(my_dict.keys())
# 输出所有值
print(my_dict.values())
7、集合Set
集合（set）是一个无序的不重复元素序列。 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。 可以使用大括号{}创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
{}符号让你想到了什么？字典对不对，但是字典是一个个键值对，而集合是单独元素，并且没有顺序
那我们用{}创建的是字典呢，还是集合呢？
我们来看下
my_now = {}
print(my_now, type(my_now))
# 输出结果
{} <class 'dict'>
用{}符号创建的是字典，而不是集合，所以创建集合我们必须使用set()函数来创建
my_now = set() print(my_now, type(my_now)) # 输出结果 set() <class 'set'>集合中的元素不会重复，所以我们可以集合去重 还可以进行交集、并集、差集等常见的集合操作，我们可以用来找出两个集合中的交集、并集、差集
my_list = ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'f']
my_set2 = {'a', 'b', 'c', 'd', 'e'}
# 1. 去重
my_set1 = set(my_list)
print(my_set1)
# 2. 交集
print(my_set1 & my_set2)
# 3. 并集
print(my_set1 | my_set2)
# 4. 差集
print(my_set1 - my_set2)
# 输出结果
{'a', 'e', 'd', 'f', 'c', 'b'}
{'a', 'c', 'e', 'd', 'b'}
{'a', 'e', 'd', 'f', 'c', 'b'}
{'f'}
8、数据类型转换
| 函数 | 描述 |
int(x ,base)
|
将x转换为一个整数 |
| long(x ,base ) | 将x转换为一个长整数 |
float(x)
|
将x转换到一个浮点数 |
| complex(real ,imag) | 创建一个复数 |
str(x)
|
将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s)
|
将序列 s 转换为一个元组 |
list(s)
|
将序列 s 转换为一个列表 |
set(s)
|
转换为可变集合 |
dict(d)
|
创建一个字典。d 必须是一个序列 (key,value)元组。 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| unichr(x) | 将一个整数转换为Unicode字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
整数与字符串、浮点数转换
num = 10 # 查看数据类型 print(type(num)) # 整数转换字符串 print(str(num),type(str(num))) # 整数转换浮点数 print(float(num),type(float(num)))
字符串转换整数、浮点数
my_str = '123' # 字符串转换整数 print(int(my_str), type(int(my_str))) # 字符串转换浮点数 print(float(my_str), type(float(my_str)))
列表与元祖的转换
# 列表转换为元组 my_list = [1, 2, 3] my_tuple = tuple(my_list) print(my_tuple) # 输出: (1, 2, 3) # 元组转换为列表 my_tuple = (4, 5, 6) my_list = list(my_tuple) print(my_list) # 输出: [4, 5, 6]
字符串与列表的转换
# 字符串转换为列表 my_string = "Hello" my_list = list(my_string) print(my_list) # 输出: ['H', 'e', 'l', 'l', 'o'] # 列表转换为字符串 my_list = ['W', 'o', 'r', 'l', 'd'] my_string = ''.join(my_list) print(my_string) # 输出: "World"
字典和列表的转换
# 字典转换为列表
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_list = list(my_dict.items())
print(my_list) # 输出: [('a', 1), ('b', 2), ('c', 3)]
# 提取出字典中的键
keys_list = list(my_dict.keys())
print(keys_list) # 输出: ['a', 'b', 'c']
# 提取出字典中的值
values_list = list(my_dict.values())
print(values_list) # 输出: [1, 2, 3]
# 列表转换为字典
my_list = [('a', 1), ('b', 2), ('c', 3)]
my_dict = dict(my_list)
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
标签：输出,数据类型,list,列表,字符串,print,day04,my From： https://www.cnblogs.com/nuomituan/p/17709427.html