【2.0】变量、常量和控制语句

【一】变量、常量和控制语句

【1】快捷键

• Ctrl + /：行注释/取消行注释
• Ctrl + Alt + L：代码格式化
• Tab / Shift + Tab：缩进、不缩进当前行
• Ctrl+X/Shift+Delete：剪切当前行或选定的代码块到剪贴板
• Ctrl+C/Ctrl+Insert：复制当前行或选定的代码块到剪贴板
• Ctrl+V/Shift+Insert：从剪贴板粘贴
• Ctrl + B / Ctrl + Click：跳转到声明
• Ctrl + 鼠标左键：悬浮/单击鼠标左键，显示简介/进入代码定义
• Ctrl + D：复制选定的区域或行

【2】注释

对代码的解释说明，注释内容不会被代码执行

• 如何进行注释
  • 单行注释，语法 # + 注释内容
  • 多行注释：三引号或者三个单引号 回车 ''' 这就是单行注释 ''' """ 这就是多行注释"""

 #[一]变量和常量
 # [1] 常量
 # 常量就是固定不变的量
 #即使是常量我也可以更改，但是在其他语言中常量是不允许更改

 #[2]变量
 #变量就是表示能够变化的状态和值
 #人的年龄，身高，体重

 #[3]代码中同样的有名字来表示相应的值和状态
 #身份证上的地址：常量表示
 #年龄：变量表示

 #变量的语法
 #变量名 = 变量值
 # <1>变量名的命名规范
    
 #可以使用数字 +字母 +下划线表示变量名

 #可以任意组合
 #数字不能开头
 #Python中的关键字不能作为变量名 if else def

 #<2>变量名的命名风格
 #驼峰体
 #大驼峰：每一个单词的首字母都大写 UserName
 #小驼峰：第一个单词首字母小写，其他首字母大写 userName
 #组合风格，任意数字+字母---->下划线 user_name

#[二]变量的三大特性
#变量值 变量类型 变量的空间地址
#实际存在的值 值的类型 实际存在的空间地址

#变量名 = 变量值 内部的原理
#首先起一个名字
#变量值：就是在内存空间中开辟一块空间存储指定的值

#如何查看三大特性
#变量值：直接通过打印变量名
#变量类型：type()
#变量的内存空间地址：id()

【二】：八数据类型

【1】基本数据类型介绍：

• 数字类型

  • 整数类型（int）
  • 浮点类型(float)

• 字符串类型(str)

• 列表类型(list)

• 字典类型(dict)

• 布尔类型(bool)

• 元组类型(tuple)

• 集合类型(set)

【2】数字类型：

整数或者浮点（小数）

• 整数类型：用于表示整数，是一种基本的数字类型，广泛用于表示计数，索引等整数的值
• 语法：变量名 = 整数值

age = 18
print(type(age))   #<class 'int'>
#语法：做算术运算
print(1 + 1)
print(2 > 1)

#【2】浮点数类型
#浮点类型用于表示带有小数部分的数值，适用于需要更精确表示的情况
#语法：变量名 = 浮点数值(小数值)
salary= 100.45
print(type(salary))   #<class 'float'>

【3】字符串类型：

字符串类型用于表示文本信息，是一种非常重要的数据类型，用于处理文字，字符等信息

name = "dream"
print(type(name))   #<class 'str'>
#语法：
#1.单引号包裹起来的字符
#2.双引号包裹起来的字符
#3.三个单引号包裹起来的字符
#4.三个双引号包裹起来的字符
name_1 = "dream"
print(name_1, type(name_1))
name_2 = 'dream'
print(name_2, type(name_2))
name_3 =  '''dream'''
print(name_3, type(name_3))
name_4 = """dream"""
print(name_4, type(name_4))

#引号嵌套
name_5 = "my name is dream , i hope yourlife is wonderful"
name_5 = 'my name is dream , i hope yourlife is wonderful'
#左边的单引号和右侧单引号被切开了
#name_5 = 'my name is dream , i hope yourlife is 'wonderful''
name_5 = 'my name is dream , i hope yourlife is "wonderful"'
name_5 = "my name is dream , i hope yourlife is 'wonderful'"
print(name_5)
name_6 = '''
1
2
3
4
5
'''
print(name_6)

#补充：字符串的使用方法
#数字进行乘法---->数字相乘得到乘法的结果
print(2 * 2)  #4
#字符串 * 数字 ----->当前字符串被重复出现指定次数
print("d" * 5)  #ddddd

#数字进行加法----> 得到加法的结果
print(1 + 1)  #2
#字符串 + 数字----> 不行 因为数据类型不同无法计算
#字符串 + 字符串 ---->将两个字符拼接在一起
print("d" + '1')    #d1

#索引求值
# 正向索引值 ，索引下表从0开始
print("dream"[0])   #d
print("dream"[1])   #r
#负向索引求值， 索引下表就从-1
print("dream"[-1])   #m
#[4]字符串格式化输出语法

sentence_one = "my name is dream , my age is 18"
sentence_two = "my name is hope , my age is 28"
sentence_three = "my name is opp , my age is 38"
#不断修改同一块代码 为了方便于是有了格式话输出语法
#  （1）方案1 %s 站位
sentence_four = "my name is %s , my age is %s"
print(sentence_four % ("dream", 18))   #my name is dream , my age is 18
print(sentence_four % ("hope", 28))   #my name is hope , my age is 28


# ● 在上例中，%s 和 %d 是占位符，分别表示字符串和整数，而 (name, age) 是传入这两个占位符的实际值。
# ● 占位符类型
#   ○ %s：字符串
#   ○ %d：整数
#   ○ %f：浮点数
#   ○ %x：十六进制整数

#(2) format方法输出：用{}站位
sentence = "my name is {} , my age is {}"
print(sentence.format("dream", 18))   #my name is dream , my age is 18
#format 按照 {}位置传参的时候如果位置替换就会导致替换错乱
print(sentence.format(18, "dream_format"))   #my name is 18 , my age is dream_format


#可以用关键字占据指定位置{name}站位  在传递参数的时候按照关键字传参数
sentence = "my name is {name} , my age is {age}"
print(sentence.format(name="dream", age=18))  #my name is dream , my age is 18
print(sentence.format(age=18, name="dream"))  #my name is dream , my age is 18

#方案三：f"{name}"
name = "dream_f"
age = "18"
sentence = f"my name is {name} , my age is {age}"   #my name is dream_f , my age is 18
print(sentence)

[4]列表类型

#存储多个人的名字时
uesr_names = ["dream", "hope", "opp"]
#取出dream这个人的名字

#索引取值
#正向取值 从 0 开始 从头到尾
#负向取值 从-1  开始 从尾到头
print(uesr_names[0])
print(uesr_names[-3])


data_info = ["dream", "hope", "opp",[
    18, 19, 20, [
        "muaic", "run", "swim"
    ]
]]

#打印 my name is name ,my age is age, my hobby is bobby
print(f"my name is {data_info[0]}, "
      f"my age is {data_info[3][0]}, "
      f"my hobby is {data_info[3][3][0]}")

[5]字典类型

#语法：{"key":"value"}

person_info = {
    "name": "dream",
    "age": 18,
    "gender": "male"
}
#存储方式一：字典["key"]
print(person_info["name"])
print(person_info["age"])
#方式二：字典。get(""key)
print(person_info.get("gender"))

# 方式一： 字典["key"] 如果字典中没有指定的键就会报错

# print(person_info["hobby"])
# 方式二：字典.get("key") 如果字典中没有指定的键不会报错
print(person_info.get("hobby"))  # None

[6]布尔类型

# 布尔类型：
#布尔类型只有True 和False,用来表示逻辑的对错
#语法：变量名 = True / False
#Python中True为真
# print(bool(1))       True
print(bool(True))    #True
print(bool(" "))  #True
# False为假  包括：False 0 空的变量（空的字符串/空列表/空字典）
print(bool(False))
print(bool(0))
print(bool(""))
print(bool([]))
print(bool({}))

[7]元组类型

#元组（tuple) 是一种不可变的序列类型，类似于，用于存储多个有序元素
#元组与列表的主要区别在于元组的元素不能被修改，删除或添加，是不可改变的数据类型
#元组通常用于存储相关联的数据，保持数据的完整性
#字符串如果后面加一个，

name = "dream",
name_tuple = ("dream")
# name_tuple = (1)
print(name, type(name))    # ('dream',) <class 'tuple'>
print(name_tuple, type(name_tuple))    #dream <class 'str'>
#总结：当元组只有一个元素的时候要加上逗号，
#如果是字符串或者整数类型的时候加上  ，  就变成了元组类型

#元组按照位置解包
name_age = ("dream", 18)
name, age = ("dream", 18)
print(name, age)

[8]集合类型

#集合类型
#集合（set）是一种无序且不重复的数据类型
#用于存储多个无序的且不重复的元素
#语法：以单个元素的形式在大括号中存储数据
num = {1,2,3,4,1,1,2,23,5}
print(num, type(num))  #{1, 2, 3, 4, 5, 23} <class 'set'>

#如果集合里面是字符串，输出的每次结果顺序会不同
One = {"o", "n", "e","a"}
print(One)

#集合里面不能放列表，元组，字典
#集合运算：并交插补
# 【1】向集合里面添加元素
Two_set = {"dream", "opp"}
Two_set.add("app")
print(Two_set)
#【2】集合删除元素
#按照指定的值删除指定元素
Two_set.remove("dream")

#集合运算
set = {1,2,3,4,5,6}
set_1 = {4,5,6,7,8,9}
#(1)并集
print(set.union(set_1))
#(2)交集
print(set.intersection(set_1))
#(3)交集
print(set.difference(set_1))

[三]程序与用户交互

#[一]为什么要交互
#登录某个网站的时候要输入用户名和密码
#代码----->通过逻辑认证 程序给我们反馈登录的结果
#如何交互
#[1]用户输入内容
#input:在输入框里面提示用户要输入的信息
Three = input("username:>>>>")
#注意：通过input语句输入的内容获取到的结果是字符串类型

# 既然得到的事字符串的 1  ---> 转换成 数字类型的 1
# 数字类型  int 类型
# 只能转换符合整数类型的字符串
'''
username = int(username)
password = int(password)
result = username + password  # 1 + 2 = 3
print(result)

#[2]输出
#有一个默认参数 end = "\n" \n代表换行
print("dre\nam")
print(1, end = "*")

【四】基本运算符

#算术运算符
#逻辑运算符
#比较运算符
#增量运算符
#[一]算术运算符
#进行算数运算的运算符
# + - / % ** //
a = 10
b = 3
print(a + b)
print(a - b)
print(a * b)
print(a // b) #取余数
print(a ** b) #幂次方
print(a // b) #取模（取商）
#比较运算符
# > >= < <= == !=
print(a>b)
print(a>=b)
print(a<b)
print(a<=b)
print(a==b)
print(a != b)
#赋值运算符
# =  +=  -=  *=  /=  %=  //=  **=
a += b
#a = a + b
print(a) #13

a -= b
print(a) #10

a *= b
print(a)

a /= b
print(a) #10.0

a %= b
print(a) #1.0

a //= b
#a = a // b
print(a)
#[1]链式赋值
a = b =c =d =22
#[2]交叉复制
a = 10
b = 3
a, b = b, a
print(a) #3
print(b) # 10

#[解压赋值]
# 可以将列表 / 元组 / 集合 能够索引取值的类型中的每一个元素按照位置获取出来
num_list = [1,2,3]
a,b,c = num_list
# a,b,c = [1, 2, 3]
print(a)
print(b)
print(c)

# 列表中的元素个数不够前面的变量解压的时候就会报错
# a,b,c,d = num_list
# not enough values to unpack (expected 4, got 3)

# 如果列表中的元素多余位置变量的时候也会报错
# a, b = num_list
# print(a)
# print(b)  # too many values to unpack (expected 2)

# 可以用下划线来存储不需要的变量值
# a, b, _ = num_list
# print(a)
# print(b)
#[四]逻辑运算符
#与或非
#与：两者都必须 and
#或：两者任一 or
#非 ：取反 not

#提高运算的优先级 对优先的部分加（）
#运算的优先级：not > and > or
#[5]成员运算符
#判断某个成员在某个成员里面
#in / not in
num_list = [1, 2, 3]
print(1 in num_list) #True
print(6 in num_list)  #False
print(6 not in num_list)  #True
#[六]身份运算
#判断这个值是否是另外一个值
a = 1
b = "1"
print(a == b)  # 比较值 # False
print(a != b)  # True
print(a is b)  # False
print(a is not b)  # True

# 【== 和 is 的区别】
# == 比较的是值 两个值是否相等
# is 比较的是值 和 内存地址是否相等

【五】流程控制语句

【1】什么是流程控制语句

#就是程序在运行过程中控制流程的语句

[2] 流程控制语句的三种方式

#顺序结构 ----> 按照顺序执行代码
#分支结构 ----->有条件约束，达到了某个条件才会执行代码
#循环结构 ----> 循环执行代码

[3]顺序结构

# 程序按照顺序依次执行代码，一句接一句的执行

[4]分支结构

# 分支结构式程序在运行过程中达到某一条条件才会执行代码结构
#[2]单分支结构
# 程序在运行过程中，如果达到了某个条件，就会执行该条件下的代码

score = 70
if score >=60:
    print(f"优秀")
    
#【3】双分支结构
#程序在运行过程中有两个条件，要么达到条件一 执行条件一的代码
#要么达到条件二 执行条件二的代码
'''
if 条件1:
	...
else:
	...
'''
#[3]多分支结构
#程序在运行过程中有多个条件进行约束和判断
#当程序遇到某一个条件就执行当前条件下的代码
'''
if 条件一:
    条件1执行的代码
elif 条件二:
    条件2执行的代码
elif 条件三:
    条件3执行的代码
else:
    上面所有条件均不符合的代码
'''

【5】循环结构

#循环结构：重复执行代码直至代码达到某个条件才会终止
#循环结构 while
'''
while 终止条件:
    代码
# 让 while 里面的代码一直执行 执行到 符合 终止条件 的时候自动终止循环
'''

#[1]关键字range
#int 转换符合数字类型的字符串
#（1）生成一个 指定区域的数字列表
print(list(range(1, 5)))  # [1, 2, 3, 4]
#元组和集合都可以生产

#(2)重复执行代码 执行次数
#range(起始数字，结束数字) #range结束字符是取不到的 包头不包尾

#range 如果第一个参数位置不屑 默认为0

#[2]continue
#搭配 while循环使用
# 在while循环内部 如果当前条件满足的时候不需要执行跳过即可
count = 0
while count < 5:
    count += 1
    # 当count = 3的时候不打印3 其他的打印
    # continue ： 让当前while循环跳出本次循环
    if count == 3:
        print(f"已跳出本次循环 {count}")
        continue
    else:
        print(count)
#【3】break关键字
#当程序循环执行达到某一条件时候就想结束整个程序

#死循环：
#while的循环条件一直为真的时候就会一直执行
#while内部代码
#在写代码的时候应该避免出现死循环

【6】三元运算

#三元表达式：
# 为真的结果 if条件 else 条件为假的结果
a, b = 10 ,20
print(a if a>b else b)
#可以用到元组和字典中
#三元表达式只适用于简单的逻辑判断