print()
//输出到控制台
print("我今年",age,"岁了")

type(variable)
# 返回variable的类型信息
# literal，也可以输出字面量的类型

int(x)
# 把x转换为一个整数

float(x)

str(x)
# str(x)可以把variable转换为字符串
# 所有变量都可转换成数字
# 字符串转换成数字必须符合其规则，int（只有数字）


exit()
//退出解释器

1.单行注释中能否使用多行注释
如果多行注释只占用一行，单行注释可以嵌套多行注释；若多行注释占用多行，则无法嵌套了，
2.多行注释中能否使用单行注释
可以。这种情况下，无论外层的多行注释占用几行都没有问题。
3.多行注释中能否使用多行注释
不可以。无论多行注释嵌套的多行注释共占据单行还是多行，都不可以成功。
多行注释嵌套多行注释，势必为"“”“”“注释内容”“”“”"。计算机会将最前面的三对双引号视为多行注释，再将最后面的三对双引号视为多行注释符，这两者的注释内容都为空。而真正的注释内容却暴露在外，没有多行注释符的提示，系统无法识别，只会认为是语法错误。

print(字面量)，

如：
print(10)，输出整数10

print(13.14)，输出浮点数13.14

print("黑马程序员")，输出字符串：黑马程序员
# 整数与浮点数的字面量都与现实中的写法相同
# 只有字符串在程序中的写法相比较现实中的写法需要多加一个双引号“”

int(x)
float(x)
str(x)

x = True
int(x) = 1
float(x) = 1.0

# 浮点数转换为整数会丢失精度

False 
True
None
# 这三个关键字首字母大写
定义false,true,none不算占用关键字

+
-
*
/
# 直接得到小数！

//
# 取整除
# 注意和java，c都不一样

%
# 取余

**
# 指数
# x**y:x的y次方

name = '"李华"'
# 在字符串中包含双引号

name = "'李华'"
# 在字符串中包含单引号

name = '\"李华\"'
name = "\'李华\'"
#  转移zi'fu

message = "我是练习时常%d年半的个人偶像练习生" % 2
message = "我是练习时常%s年%s的个人偶像练习生" % (2,0.50)
> 我是练习时常2年0.5的个人偶像练习生
message = "我是练习时常%s年%s的个人偶像练习生" % (2,0.50)
> 我是练习时常2年0.500000的个人偶像练习生
# %s 万物皆可转换成字符串

%s:字符串
%d:整数
%f:浮点数

print("1*1的结果是:%d" % (1*1))
print(f"1*1的结果是:{1*1}")
print("字符串在Python中的类型名是：%s" % type("字符串"))

name = input("请告诉我你的银行卡密码")
# 也可以手动提示，提前用print打印提示信息
print("你的银行卡密码的数据类型是：",type(num))
# input输入的永远是字符串类型

a = True
print("%s" % a)
> True

a = True
print(a-1)
> 0

a = True
print(a > 3)
> False

a = True
print(a > 0)
> True

# 布尔变量在做运算的时候是当做1和0来进行运算的

age = 18
# 判断语句的结果，必须是布尔类型True或False
if age >= 18:
# 需要一个冒号
    print("我已经成年了")
    print("我要上大学了")
# 归属于if判断的代码语句块，需要在前方填充4个空格缩进
# Python通过缩进判断代码块的归属关系
print("时间过的真快")

age = int(input("请输入您的年龄："))
if age >= 18:
    print("您已经成年，需要买票")
elif age <= 10:
    print("您未成年，不需要买票")
else:
    print("mmmmm")
print("欢迎游玩")

name = "python"
for x in name:
    print(x)

range(num)
# 从0取到num-1
range(5)=[0,1,2,3,4]

range(num1,num2)
# 从num1取到num2（不包含num2本身）
range(5,10)=[5,6,7,8,9]

range(num1,num2,step)
# 从num1开始，到num2(不包含num2),是以step为间隔
range(5,10,2)=[5,7,9]

continue:进入下一个循环
break:结束当前循环

#  函数的定义
def name(variable):
    body
    return value
# 注意:python不用写返回类型，自动匹配

def func(x, y):
    """
    函数说明
    :param x: 形参x的说明
    :param y: 形参y的说明
    :retrun: 返回值的说明
    """
    body
    return 返回值

num = 100
def testB()
    # global 关键字是声明a是全局变量
    global num
    num = 200
    print(num)
testB
print(f'全局变量num = {num}')
# 是对全局变量进行修改了
# 不加global不弄修改全局变量num，而是重新定义一个局部变量num

# 字面量
[元素1, 元素2, 元素3, 元素4, ...]

# 定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]

# 定义空列表
变量名称 = []
变量名称 = list()

# 语法： 列表[下表索引]

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0])
print(name_list[1])
print(name_list[2])
>
Tom
Lily
Rose

# 支持反向索引

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
>
Rose
Lily
Tom

# 支持嵌套索引

my_list = [ [1, 2, 3], [4, 5, 6] ]

print(my_list[0])

print(my_list[0][0])

# 查询
# 语法：列表.index(元素)
# 功能：查找指定元素在列表的下标

my_list = ["itheima", "itcast", "python"]
print(my_list.index("itcast"))

>
1

# 修改
my_list = [1, 3, 5]
my_list[0] = 5
print(my_list[0])

my_list = [1, 3, 5]
my_list[-3] = 5
print(my_list)


# 插入
my_list = [1, 2, 3]
my_list.insert(1, "itheima")
print(my_list)

>
[1, 'itheima', 2, 3]

# 追加
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)
>
[1, 2, 3, 4]

my_list = [1, 2, 3]
my_list.append([4, 5, 6])
print(my_list)
[1, 2, 3, [4, 5, 6]]

# 追加元素2
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)
> 
[1, 2, 3, 4, 5, 6]

# 删除元素
my_list = [1, 2, 3]

del my_list[0]
print

my_list.pop(0)
print(my_list)

1. 可以容纳多个数据（上限是2**63-1）

2. 可以容纳不同类型的数据（混装）

3. 数据是有序存储的

4. 允许重复数据存在

5. 可以修改

# 定义元组字面量
(元素，元素，......，元素)

# 定义元组变量
变量名称 = (元素,元素,.....,元素)

# 定义空元组
变量名称 = ()        # 方式1
变量名称 = tuple()     # 方式2

注意！
# 定义3个元素的元组
t1 = (1, 'hello', True)

# 定义1个元素的元组
t2 = ('hello', )    # 注意，必须带有逗号，否则不是元组类型，而括号内唯一元素的类型

# 元组也支持嵌套
t1  = ( (1, 2, 3), (4, 5, 6) )

# 根据下标（索引）去除数据
t1 = (1, 2, 'hello')

# 根据index(),查找特定元素的的第一个匹配项
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello'))

# 统计某个数据在元组内出现的次数
t1 = (1, 2, 'hello', 3, 4, 'ehllo')
print(t1.count('hello'))

# 统计元组内的元素的个数
t1 = (1, 2, 3)
print(len(t1))

注意！

1. 不可以修改元组的内容，否则会直接报错

2. 可以修改元组内的list的内容

3. 不可以替换list为其他的list或其他类型

1. 可以容纳多个数据

2. 可以容纳不同类型的数据（混装）

3. 数据是有序存储的（下标索引）

4. 允许重复数据存在

5. 不可以修改（most important）

6. 支持for循环

同元组一样，字符串是一个：无法修改的数据容器。

不能！
1. 修改指定下表的字符    (str[0] = 'a')

2. 移除特定下表的字符    (del str[0])

3. 追加字符                (str.append())

如果必须要进行以上操作，只能得到一个新的字符串，旧的字符串是无法修改的

# 查找特定字符串的下标索引值
my_str = "itcast and itheima"
print(my_str.index("and"))

# 字符串的替换（不是修改）
name = "itheima itcast"
new_name = name.replace("it", "he")

print(new_name)            # 结果，hetheiam hecast
print(name)                # 结果，ittheiam itcast

    可以看到，字符串name本身并没有发生变化
    而是得到了一个新的字符串对象

# 字符串的分割

name = "it he she"
name_list = name.split(" ")

print(name_list)        # 结果，['it', 'he', 'she']
print(type(name_list))     # 结果：<class 'list'>

.split函数是将给定的分割符对字符串进行分割，变成多个子字符串，并存入一个列表对象中。

# 字符串的规整操作1（去前后空格）

my_str = " itheima and itcast "
print(my_str.strip())            #结果："itheima and itcast"


# 字符串的规整操作2（去前后指定字符串）

my_str = "12itheima and itcast21"
print(my_str.strip("12"))         # 结果："itheima and itcast"
——————————————————————————————————————————————————————————————————————？
问题：
1. 无论是12还是21都可以去除
2. 21i会把前面的去掉，但是后面的不变
——》推测不根据顺序，而是一个无顺序的集合


# 统计字符串中某字符串的出现次数

my_str = "itheima and itcast"
print(my_str.count("it"))         # 结果:2

# 统计字符串的长度

my_str = "1234 abcd !@#$"
print(len(my_str))                # 结果:14

1. 只能存储字符串

2. 长度任意

3. 支持下标索引

4. 允许重复字符存在

5. 不可以修改

6. 支持for循环

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

>>
    不是由函数实现功能，是根据两个中括号来实现，推测是把函数内嵌进入python编辑器里边。

- 首先所有的序列都可以使用这个切片功能，包括元组，字符串，列表都可以

- 步长的含义：1:表示一个一个取元素
            2:表示跳过一个元素取
            3:步长可以用负数表示，表示反向取，此时，起始下标和结束下标也要反向标记
            4:反向标记，可以用来反着取比如12345取54321

！注意：步长不可以为0，其实想想就知道，走0步不就一直停在那了

- 列表：[]
- 元组：()
- 字符串：""
- 集合：{}

# 定义集合字面量
{元素, 元素, ......, 元素}

# 定义集合变量
变量名称 = {元素, 元素, ......, 元素}

# 定义空集合
变量名称 = set()

- 不重复
    即使在定义集合变量的时候由重复的元素，也会自动去重

- 没有顺序
    不能保证顺序与创建的时候一致
    不支持下标索引

- 可以修改
    增加或删除元素等

- 支持for循环

# 修改
my_set = {"hello", "world"}
my_set.add("itheima")
print(my_set) # 结果{'hello', 'itheima', world}

# 移除
my_set = {"hello", "world", "itheima"}
my_set.remove("hello")
print(my_set)     # 结果 {'hello', 'itheima'}

# 随机取出元素
my_set = {"hello", "world", "itheiam"}
element = my_set.pop()
print(my_set)    # 结果 {'world', 'itheima'}
print(element)    # 结果 'hello'

# 清空集合
my_set = {"hello", "world", "itheiam"}
my_set.clear()
print(my_set)    # 结果：set()    空集合

# 取出两个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set3)
print(set1)
print(set2)

# 消除两个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)    # {2, 3}
print(set2)    # {1, 5, 6}
！注意，此时集合1被修改，但是集合2不变

# 两个集合合并
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)    # 结果：{1, 2, 3, 5, 6}，新集合
print(set1)    # 结果：{1, 2, 3}，set1不变
print(set2)    # 结果：{1, 5, 6}，set2不变

# 查看集合的元素的数量
set1 = {1, 2, 3}
print(len(set1))    # 结果：3

# 集合同样支持使用for循环遍历
set1 = {1, 2, 3}
for i in set1:
    print(i)

# 结果
1
2
3

# 定义字典字面量
{key: value, key: value, ..., key: value}
# 定义字典变量
my_dict = {key: value, key: value, ..., key: value}
# 定义空字典
my_dict = {}    # 空字典定义方式1
my_dict = dict()# 空字典定义方式2

注意：
- 使用{}存储原始，每一个元素是一个键值对
- 每一个键值对包含Key和Value（用冒号分隔）
- 键值对之间使用逗号分隔
- Key和Value可以是任意类型的数据（key不可为字典）
- Key不可重复，重复会对原有数据覆盖

# 语法，字典[key]可以取到对应的value
stu_score = {"王力宏": 99, "周杰伦": 88, "林俊杰": 77}
print(stu_score["王力宏"])    # 结果：99
print(stu_score["周杰伦"])    # 结果：88
print(stu_score["林俊杰"])    # 结果：77

stu_score = {
    "wang": {"chinese": 77, "math": 66, "English": 33}
    "zhou": {"chinese": 88, "math": 86, "English": 55}
    "lin": {"chinese": 99, "math": 96, "English": 66}
}

print(stu_score["wang"])    # 结果：{"chinese": 77, "math": 66, "English": 33}

# 新增元素
stu_score["zhang"] = 66

# 修改元素
stu_score["wang"] = 100



# 删除元素
value = stu_score.pop("wang")
print(value)        # 结果：77
print(stu_score)    # 结果：wang的key已经消失

# 清空字典
stu_score.clear()

# 获取字典中的全部的key
keys = stu_score.keys()
print(keys) # 结果：dict_keys(['wang', 'zhou', 'lin'])

# 遍历字典
stu_score = {"王力宏": 99, "周杰伦": 88, "林俊杰": 77}
keys = stu_score.keys()
for key in keys:
    print(f"学生:{key},分数:{stu_score[key]}")

# 计算字典内键值对的数量
stu_score = {
    "王力宏": 99, 
    "周杰伦": 88, 
    "林俊杰": 77
}
print(len(stu_score))        # 结果：3

经过上述对字典的学习，可以总结出字典有如下特点：

1. 可以容纳多个数据

2. 可以容纳不同类型的数据

3. 每一份数据是KeyValue键值对

4. 可以通过Key获取到Value，Key不可重复（重复会覆盖）

5. 不支持下标索引

6. 可以修改（增加或删除更新元素等）

7. 支持for循环，不支持while循环