1 变量
1.1 学习变量的目的
# 学习变量有助于我们在程序中存储和操作数据，提高代码质量，更方便我们操作和修改数据。1.2 学习基本数据类型的目的
#是在不同的场景下使用对应的数据类型来操作数据2 八大数据类型介绍
- 【1】数字类型
-
- （1）整数类型
- （2）浮点数类型
- 【2】字符串类型
- 【3】列表类型
- 【4】字典类型
- 【5】布尔类型
- 【6】元组类型
- 【7】集合类型
2.1 数字类型(int)
2.1.1 整数类型（int）
# （1）用途
# 用来标识整数，最广泛使用的数据类型之一
# （2）语法
# 语法 ：
# 变量名 = 数字
age = 18
# 可以查看当前变量的变量类型
print(type(age)) # <class 'int'>
# （3）使用场景
# 可以用来进行加减乘除的运算2.1.2 浮点数类型(float)
# （1）用途
# 可以用来表示带小数的数值
# （2）语法
# 变量名 = 浮点数
weight = 88.00
print(type(weight)) # <class 'float'>
# （3）场景
# 取款的时候你会发现取款金额和余额都不是整数
# 100.002.2 字符串类型(str)
# 【1】用途
# 用来标识文本信息
# 【2】语法
# 变量名 = 变量值(加引号 ，一个单引号，一个双引号，三个单引号，三个双引号)
name = "dream"
print(name,type(name)) # dream <class 'str'>
name = 'Dream'
print(name, type(name)) # Dream <class 'str'>
name = '''Dream'''
print(name, type(name)) # Dream <class 'str'>
name = """Dream"""
print(name, type(name)) # Dream <class 'str'>
# 如果单双引号进行混用
name = "'name'" # 双引号中混用的单引号
print(name, type(name)) # 'name' <class 'str'>
name = '"name"' # 单引号中混用的双引号
print(name, type(name)) # "name" <class 'str'>
# 测试在双引号内存出现单独的单引号
name = "name'"
print(name, type(name)) # name' <class 'str'>
name = 'name"'
print(name, type(name)) # name" <class 'str'>
sentence = "my name is dream ,I'm 18 years old,hope you 'wonderful!'" #这就完全没问题
sentence = 'my name is dream ,I'm 18 years old,hope you "wonderful!"'
# 中间的 ' 产生了歧义 按照正常的字符串语法 单双引号应该成对出现
# 所以在单引号内部不能出现单独单引号，但是单引号内部可以出现单独的双引号
sentence = "my name is dream ,I"m 18 years old,hope you 'wonderful!'"
# 所以在双引号内部不能出现单独的双引号，但是双引号内部可以出现单独的单引号
# 在三引号内部，如果第一行和最后一行不写内容默认存在一个换行
sentence = '''
my name is dream ,
I'm 18 years old,
hope you 'wonderful!'
'''
print(sentence, type(sentence)) # <class 'str'>在三引号内部，如果第一行和最后一行不写内容默认存在一个换行
想取消掉只需要把内容移上去即可
# 【3】使用方法
# （1）字符串加法
print(1 + 1) # 2
# 字符串 + 字符串 = 字符串
print("1" + "1", type("1" + "1")) # 11 <class 'str'>
# （2）字符串乘法
print(1 * 9) # 9
# 字符串 * 数字 = 当前字符串重复出现几次
print("1" * 9) # 111111111
# （3）可以索引取值
# 索引的意思就是坐标 -3 -2 -1 0 1 2 3
# H e l l o W o r l d
# 0 1 2 3 4 5 6 7 8 9 10
# 支持索引取值
word = "Hello World"
# 索引取值的语法 字符串[索引坐标]
# 取出来的值还是字符串
print(word[0]) # w
print(word[5], type(word[5])) # <class 'str'>
print(word[10]) # d
# 支持负索引取值
# 索引的意思就是坐标 -3 -2 -1 0 1 2 3
# H e l l o W o r l d
# -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
print(word[-1]) # d
print(word[-6], type(word[-6])) # 第六位是空格 虽然不显示但是确实是有 <class 'str'>
# 计算当前字符串的总字符数
# 计算当前字符串的总字符数
print(len(word), type(len(word))) # 11 <class 'int'>
# 当我们使用正索引取值的时候，索引是从 0 开始 0 - 10
print(word[len(word) - 1]) # d
# 如果是负索引取值，从 -1 开始 ，可以取到 -11
print(word[-len(word)])
# 【4】字符串的格式化输出
# myself_sentence = "my name is dream,my age is 18,"
# myself_sentence = "my name is hope,my age is 18,"
# 变量可以用来存储值
name = "hope"
age = 18
# myself_sentence = "my name is name,my age is age"
# （1）%占位输出法
# myself_sentence = "my name is %s,my age is %s" % (name, age)
# %s : string字符串类型的数据
# %d : int数字类型的数据
# myself_sentence = "my age is %d,my name is %s" % (name, age)
# TypeError: %d format: a real number is required, not str（这里报错是因为程序运行最后还是name, age）
name = "hope"
age = 18
myself_sentence = "my name is %s,my age is %d" % (name, age)
print(myself_sentence) # my name is hope,my age is 18
# （2）f + {}
# myself_sentence = f"my name is {name},my age is {age}"
# （3）format输出语法
# 按照位置传值
# myself_sentence = "my name is {},my age is {}".format(name, age)
# 按照关键字传值
myself_sentence = "my age is {age},my name is {name}".format(name=name, age=age)
print(myself_sentence) #my age is 18，my name is hope
# \ 在python中属于是转移符号
# name = "dream \n"
name = "dream\\" # dream\
print(name)
print(age)2.3 列表类型(list)
# 【1】作用
# 可以在列表中存放从多个值，不限制数据类型
# 比如我用一个列表存储很多学生的名字
# 【2】语法
name_list = ["dream", "hope"]
print(name_list, type(name_list)) # ['dream', 'hope'] <class'list'>
# 【3】放了值是为了方便使用
# （1）索引取值
# 索引取值正向从 0 开始，负向 -1 开始
print(name_list[0]) # dream
print(name_list[-1]) # hope
# 【4】索引支持嵌套
info_list = [ "dream", ["15", ["上海"]]]
print(info_list) # ['dream', ['15', ['上海']]]
print(info_list[1]) # ['15', ['上海']]
print(info_list[1][1]) # ['上海']
print(info_list[1][1][0]) # 上海2.4 字典类型{dict}
# 【1】作用
# 可以记录多个值，并且这些值带有各自及的名字
# 字典数据存储的方式 是 key:value
# 【2】语法
# 里面存的每一个值都是 key:value 的 kv键值对
infO_data = {
"name": "dream",
"age": 18,
"hobby": ["music", "run", "make girlfriends"]
}
# 【3】放就是为了方便取
# （1）索引取值
# 字典不支持索引取值！
# print(infO_data[0])
# （2）根据键取值
print(infO_data["name"]) # dream
# [key] 取值，如果字典中不存在当前 键 就会报错
# print(infO_data["addr"]) # KeyError: 'addr'
# （3）.get(键)取值
print(infO_data.get("name")) # dream
# .get(key) 取值，如果字典中不存在键对应的值不会报错，而是反悔了一个 None
print(infO_data.get("addr"), type(infO_data.get("addr"))) # None <class 'NoneType'>info = {
'name': 'Dream',
'addr': {
'国家': '中国',
'info': [
666,
{'age': 18},
999,
{'编号': 466722, 'hobby': ['read', 'study', 'music']}
]
}
}
# 格式化输出
# sentence = "my name is name ,my age is age ,my id is id ,my location is location , my hobby is music-read-study"
# 从 info 字典中获取 name 键对应的值即可
name = info.get("name")
# 从 info 字典中 获取到 addr 对应的 字典 ，再 从字典中获取 键 国家 对应的值
location = info["addr"].get("国家")
age = info["addr"]["info"][1].get("age")
id = info["addr"]["info"][3].get("编号")
hobby = info["addr"]["info"][-1].get("hobby")[0] + '-' + info["addr"]["info"][-1].get("hobby")[1] + '-' + \
info["addr"]["info"][-1].get("hobby")[2]
# sentence = f"""my name is {name} ,
# my age is {age} ,
# my id is {id} ,
# my location is {location} ,
# my hobby is {hobby}
# """
sentence = f"""my name is {info.get("name")} ,
my age is {info["addr"]["info"][1].get("age")} ,
my id is {info["addr"]["info"][3].get("编号")} ,
my location is {info["addr"].get("国家")} ,
my hobby is {info["addr"]["info"][-1].get("hobby")[0] + '-' + info["addr"]["info"][-1].get("hobby")[1] + '-' + info["addr"]["info"][-1].get("hobby")[2]}
"""
print(sentence)2.5 布尔类型(bool)
# 就是我们生活中的真或假
# 真 True
# 假 Flase
is_right = True
print(is_right, type(is_right)) # True <class 'bool'>
# 在python中典型的真或假的情况
# 哪些情况是真？
# 数字 1 为真
# 哪些情况是假？
# 不存在的情况：空值为假,空的字符串、空的列表、空的字典、空的元组、数字 0
name = ""
name = []
name = {}
name = 2
# name = False
print(bool(name)) # False
name = "11"
print(bool(name)) #true2.6 元素类型
# 【1】用来存储不变的元素
name = ["dream"]
name[0] = "hope"
print(name) #["hope"]
# 特别注意：元组中有一个元素的时候一定要加 ,
# 特别注意：元组中有一个元素的时候一定要加 ,
# 特别注意：元组中有一个元素的时候一定要加 ,
name = ("dream")
print(name, type(name)) # dream <class 'str'>
name = ("dream",)
print(name, type(name)) # ('dream',) <class 'tuple'>
# name[0] = "hope"
# print(name)
# 元组的解包 ； 解压赋值
info = ("dream", 18)
print(info[0])
print(info[1])
name, age = ("dream", 18)
print(name)
print(age)2.7 集合类型
# 集合 ： 无序且去重 在集合里面看不到重复的元素
# {key:value} : 字典
# {key} : 集合
num = {1, 2, 3, 4, 5, 5, 5, 5, 5, 5}
print(num, type(num)) #{1, 2, 3, 4, 5} <class 'set'>
# 集合类型中不能存放的元素类型是 字典和列表 ： 因字典和列表是可变数据类型不能被 hash
num = {1, 2, 3, 'name', 'dream', 4, 1.11, 5, 5, 5, 5, 5, 5}
print(num)
# {1, 2, 3, 4, 1.11, 5, 'dream', 'name'}
# {1, 'name', 3, 2, 4, 1.11, 5, 'dream'}
# {'name', 2, 3, 4, 1, 1.11, 5, 'dream'} 体现了集合的无序性，要是放的全是数字就一直不会改变
扫一扫
2782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
