变量，基本数据类型，四大容器

print("Hello World!!")

# print 可以接收可变参数
print(1)
print(1, 2)
print(1, 2, 3)
print(1, 2, 3, 4)
# 指定输出对个值时的分隔符
# 例如按照 | 分割
print(1, 2, 3, 4, 5, sep="|")
# end 参数可以设置结束符 默认为'\n'
# 不换行输出
print(1, end='换行')
print(2)

# 变量
# 命名规则：大小写字母，数字，下划线，不能以字母开头，不能是关键字(保留字)
# 定义变量时必须赋值(定义即赋值）
# 定义时不需要指定类型，但不是没有类型，变量的类型可以由等号右边赋的值推断出来
# 动态数据类型
i = 10
j = 20
print(i)
print(j)
k = 10
print(k)
print("*" * 20)
print(type(i))
print(type(j))
print(type(k))
i = "abc"
print(type(i))
print("*" * 20)

import keyword

# 查看Python关键字
print(keyword.kwlist)
print("*" * 20)

# 单行注释
'''
多行注释一般用于文档说明
类似java中的/**
           *
           *
           */
这是多行注释
这是多行注释
这是多行注释
'''
"""
这是多行注释
这是多行注释
这是多行注释
"""

# 查看变量类型
# type
print(type(i))
print(type(j))
print(type(k))
print("*" * 20)

# 五大基本数据类型
# 整型int，浮点类型float，字符串类型str，布尔类型bool，空类型NoneType
i = 100
print(i, type(i))
f = 1.123
print(f, type(f))
# 可以用单引号或双引号，都表示字符串
str1 = 'abcdefg'
str2 = "hjklmn"
print(str1, type(str1))
print(str2, type(str2))
# 首字母大写
bool1 = False
bool2 = True
print(bool1, type(bool1))
print(bool2, type(bool2))

non = None
print(non, type(non))
print("*" * 20)

# 算术运算符
# + - * / ** //
int1 = 10.0
int2 = 3.33
print(int1 + int2)
print(int1 - int2)
print(int1 * int2)
print(int1 / int2)
print(10 % 3)  # 取余
print(10 ** 3)  # 1000 10的三次方
print(10 // 3)  # 3 向下取整
print("*" * 20)

# 逻辑运算
# 布尔类型通常用于逻辑运算以及条件表达式（if，while）
# 与 或 非 异或
t = True
f = False
print(t & f)  # 与
print(t and f)  # 与
print(t | f)  # 或
print(t or f)  # 或
print(not f)  # 非
print(t ^ f)  # 异或
print("*" * 20)

# 字符串类型常见的操作
# 前面定义的变量，后面可以重新定义并赋值
str1 = 'hello,world,java,python'
# 切分字符串，得到一个list
list1 = str1.split(",")
print(list1)
# 将list1中的每一个元素拼接成字符串
print("|".join(list1))
print("*" * 20)

# 去除字符串两边的隐藏字符
# 隐藏字符:\n \t 空格
str2 = '\t\n       abc     def     \t\n'
print(str2)
print(str2.strip())
print("*" * 20)

# 格式化字符串
# 按照一定的格式输出字符串
# %s %d %f
# 可以限定类型
print("%s字符串，%0.2f小数，%d整数" % ('abc', 1.236, 10))

# 使用format方法
# 5 *4=20
# {}*{}={}
str_fm1 = "{}*{}={}"
print(str_fm1.format(5, 4, 20))
print(str_fm1.format('5 ,4 6', 4, 200))

# 分页url需要page，pagesize参数
# https://www.shujia.com/stu/page=10&pageSize=10
url_format1 = 'https://www.shujia.com/stu/page={}&pageSize={}'
url_format2 = 'https://www.shujia.com/stu/page={page}&pageSize={pageSize}'
print(url_format1.format(3, 10))
print(url_format2.format(page=3, pageSize=10))
print("*" * 20)

print(str1)
print(str1.replace(",", "，"))  # 返回了新的字符串，并不会对原有的字符串产生变化
print(str1)
print("*" * 20)

# 切分字符串
# 切片
# [起始位置:结束位置:步长]
# 将字符串看成由一个个字符组成的List
# 将每一个字符看成这个List中的元素
# 每个元素都有一个位置（索引，默认从左到右，从0开始）
# 起始位置默认为第一个字符的位置
# 结束位置默认为最后一个字符的位置
str3 = '0123456'
print(str3[1:3 + 1:1])  # 123
print(str3[3:6 + 1:])  # 3456
print(str3[1:7:2])  # 1357
print(str3[::2])  # 0246
print("*" * 20)
# 位置支持负数索引
print(str3[3])  # 如果直接传入一个参数，表示按照索引位置，取元素
print(str3[-2])
print(str3[1:3])  # 如果直接传入两个参数，表示省略步长

# 步长也可以为负数
# 从由往左取
print(str3[::-1])  # 倒转字符串
print("*" * 20)

# 类型转换
# 要转换成什么类型，就调用改类型对应的类型名称对应的方法
# int() float() str() bool()
int1 = 100
float1 = 23.45
str1 = '999'
str2 = "99.99"

# str to int
str1int = int(str1)
print(str1int, type(str1int))
# str to float
print(float(str2), type(float(str2)))
# int to str
# float to str
print(str(int1), type(str(int1)))
print(str(float1), type(str(float1)))

# 转换时一定要注意 数据是否符合要求
strError = 'abcdef'
# int(strError)
print("*" * 20)

# to bool
# 数值型转bool:除零以外都是True
# 字符串转bool:除空字符串以外都是True
print(bool(11))  # True
print(bool(123))  # True
print(bool(12))  # True
print(bool(0))  # False
print(bool(-0))  # False
print("*" * 20)

print(bool(1.23))  # True
print(bool(1.0))  # True
print(bool(11.0))  # True
print(bool(0.0))  # False
print(bool(-0.0))  # False
print("*" * 20)

print(bool('abc'))  # True
print(bool(''))  # False
print(bool('True'))  # True
print(bool("False"))  # True
print("*" * 20)

10
20
10
********************
<class 'int'>
<class 'int'>
<class 'int'>
<class 'str'>
********************
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
********************
<class 'str'>
<class 'int'>
<class 'int'>
********************
100 <class 'int'>
1.123 <class 'float'>
abcdefg <class 'str'>
hjklmn <class 'str'>
False <class 'bool'>
True <class 'bool'>
None <class 'NoneType'>
********************
13.33
6.67
33.3
3.003003003003003
1
1000
3
********************
False
False
True
True
True
True
********************
['hello', 'world', 'java', 'python']
hello|world|java|python
********************
	
       abc     def     	

abc     def
********************
abc字符串，1.24小数，10整数
5*4=20
5 ,4 6*4=200
https://www.shujia.com/stu/page=3&pageSize=10
https://www.shujia.com/stu/page=3&pageSize=10
********************
hello,world,java,python
hello，world，java，python
hello,world,java,python
********************
123
3456
135
0246
********************
3
5
12
6543210
********************
999 <class 'int'>
99.99 <class 'float'>
100 <class 'str'>
23.45 <class 'str'>
********************
True
True
True
False
False
********************
True
True
True
False
False
********************
True
False
True
True
********************

# Python中的四大数据容器
# 列表list 元组tuple 字典dict 集合set

# 列表
# 定义:[元素1,元素2,元素3......]
# 特点:元素可以重复，元素类型不唯一，有序的,可变的
list1 = [1, 2, 3, 4, 5, 6, 7, 'abc', True, 1.2]
print(list1)
print(type(list1))
print("*" * 20)

# 常用方法:
# 提取一个元素,传入一个索引
print(list1[9])
# 修改一个元素
print(list1[2])
list1[2] = 3.3
print(list1)
# 增加一个元素，到list1末位
list1.append(10)
print(list1)
# 指定一个位置增加元素
list1.insert(2, 2.3)
print(list1)
print("*" * 20)
# 移除一个元素
list1.pop()  # 移除最后一个元素
print(list1)
list1.pop(5)  # 按照指定位置移除元素
print(list1)
list1.remove(4)  # 按照指定的值移除元素
print(list1)
print("*" * 20)
# 查找元素
print(list1.index(2))
print(list1.index(1.2))
# 在Python中1和True，0和False不严格区分，有些情况下等价
list1.remove(1)
print(list1)
print(list1.index(True))
# print(list1.index(False))#找不到 报错
print("*" * 20)

list2 = [1, 2, 3]
print(list1 + list2)

# 会改变原有的list
list1.extend([1, 2, 3])
print(list1)

# 倒转list
list1.reverse()
print(list1)
print(list1[::-1])  # 返回新的list
print("*" * 20)

# 统计元素的个数
print(list1.count(3))

# 排序
list2 = [2, 3, 4, 5, 2, 7, 1]
print(list2)
list2.sort()
print(list2)

# 清空一个list
list1.clear()
print(list1)
print("*" * 20)

# 元组Tuple
# 定义:(元素1,元素2,元素3.......)
# 特点:元素可以重复，元素的类型可以不唯一，有序的，不可变的(一旦创建就不能修改)
tuple1 = (1, 2, 3, 4, 5, 3, 3, 2, 'abc', True, False, 3.4)
print(tuple1)
print(type(tuple1))

print(tuple1[5])
print("*" * 20)
# 只有两个常见的方法
# index,count

# 切片
# 提取有序数据容器中的元素
# 每个元素都有一个位置（索引，默认从左到右，从0开始）
# [起始位置:结束位置:步长]
# 起始位置默认为第一个元素的位置
# 结束位置默认为最后一个元素的位置
# 步长 默认 为1
# 位置支持负数索引
# 步长也可以为负数
list3 = [1, 2, 3, 4, 5, 6]
tuple2 = (1, 2, 3, 4, 5, 6)
print(list3[1:4 + 1:1])  # 2,3,4,5
print(tuple2[1:4 + 1:1])  # 2,3,4,5
print(list3[-2:-4 - 1:-1])  # 5,4,3
print(list3[-4:-1:1])  # 3,4,5
print("*" * 20)

# 字典dict
# 定义:{k1:v1,k2:v2,k3:v3......}
# 特点:
# 1.字典中的元素都是KV格式的，类似java中的Map
# 2.无序，没有索引，可以通过key取value
# 3.key是惟一的，如果有相同的key，后面的value取覆盖前面的value
# 4.value可以是任意类型:基本数据类型或者数据容器都可
# 5.key必须是不可变的（基本数据类型，元组）
# 6.可变的
dict1 = {
    "k1": "v1",
    "k2": "v2",
    0: '0001',
    1: 100,
    1: 1000,
    2: 1000,
    True: 'true',
    False: 'false',
    1.1: '1.1',
    (1, 2, 3): 'tuple',
    # [1,2,3]:'list',
    # {"k1": "v1"}: "dict",
}

# 不支持通过索引取元素
# 可以通过key取value
print(dict1[0])  # z在这里0并不是索引而是key
print(dict1['k1'])
print(dict1[1])
print("*" * 20)

# 如果key中同时存在0和False或者1和True
# 后面出现的值会覆盖前面的值
print(dict1[0])
print(dict1[1])
print(dict1[True])
print(dict1[False])
print("*" * 20)

# 查看容器里面有多少个元素
# len()方法
print(len(dict1))

print(dict1)
print(type(dict1))

# dict 常见的操作
# 获取元素
# print(dict1['kk1'])  # 如果key不存在，就报错
print(dict1.get('kk1', 'key不存在时的返回值'))  # 如果key不存在，可以指定返回值（推荐)
print("*" * 20)

dict1.pop("k1")  # 按照指定的key移除KV
print(dict1)

print(dict1.keys())  # 获取字典中所有的key
print(dict1.values())  # 获取字典中所有的value
print(dict1.items())  # 获取字典中所有的KV
print("*" * 20)

# 增加KV
dict1['kk1'] = 'vv1'

# 修改K对应的V
dict1['k2'] = 'v2'
print(dict1)
print("*" * 20)

# 集合set
# 定义:{元素1,元素2,元素3......}
# 特点:元素唯一,会自动去重,无序,可变的,元素的类型可以不唯一
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9}
print(set1)
print(type(set1))
print(len(set1))
print("*" * 20)

# 集合之间的运算
# 交集 并集 差集
set2 = {1, 2, 3, 4, 5, 6}
set3 = {4, 5, 6, 7, 8, 9}

print(set2 & set3)  # 交集
print(set2 | set3)  # 并集
print(set2 - set3)  # 差集
print(set3 - set2)  # 差集
print("*" * 20)

print(set1)
# 增加一个元素
set1.add(1)
set1.add(10)
print(set1)
#移除一个元素
set1.pop()#随机的
set1.remove(7)#指定一个具体的元素移除
print(set1)

[1, 2, 3, 4, 5, 6, 7, 'abc', True, 1.2]
<class 'list'>
********************
1.2
3
[1, 2, 3.3, 4, 5, 6, 7, 'abc', True, 1.2]
[1, 2, 3.3, 4, 5, 6, 7, 'abc', True, 1.2, 10]
[1, 2, 2.3, 3.3, 4, 5, 6, 7, 'abc', True, 1.2, 10]
********************
[1, 2, 2.3, 3.3, 4, 5, 6, 7, 'abc', True, 1.2]
[1, 2, 2.3, 3.3, 4, 6, 7, 'abc', True, 1.2]
[1, 2, 2.3, 3.3, 6, 7, 'abc', True, 1.2]
********************
1
8
[2, 2.3, 3.3, 6, 7, 'abc', True, 1.2]
6
********************
[2, 2.3, 3.3, 6, 7, 'abc', True, 1.2, 1, 2, 3]
[2, 2.3, 3.3, 6, 7, 'abc', True, 1.2, 1, 2, 3]
[3, 2, 1, 1.2, True, 'abc', 7, 6, 3.3, 2.3, 2]
[2, 2.3, 3.3, 6, 7, 'abc', True, 1.2, 1, 2, 3]
********************
1
[2, 3, 4, 5, 2, 7, 1]
[1, 2, 2, 3, 4, 5, 7]
[]
********************
(1, 2, 3, 4, 5, 3, 3, 2, 'abc', True, False, 3.4)
<class 'tuple'>
3
********************
[2, 3, 4, 5]
(2, 3, 4, 5)
[5, 4, 3]
[3, 4, 5]
********************
false
v1
true
********************
false
true
true
false
********************
7
{'k1': 'v1', 'k2': 'v2', 0: 'false', 1: 'true', 2: 1000, 1.1: '1.1', (1, 2, 3): 'tuple'}
<class 'dict'>
key不存在时的返回值
********************
{'k2': 'v2', 0: 'false', 1: 'true', 2: 1000, 1.1: '1.1', (1, 2, 3): 'tuple'}
dict_keys(['k2', 0, 1, 2, 1.1, (1, 2, 3)])
dict_values(['v2', 'false', 'true', 1000, '1.1', 'tuple'])
dict_items([('k2', 'v2'), (0, 'false'), (1, 'true'), (2, 1000), (1.1, '1.1'), ((1, 2, 3), 'tuple')])
********************
{'k2': 'v2', 0: 'false', 1: 'true', 2: 1000, 1.1: '1.1', (1, 2, 3): 'tuple', 'kk1': 'vv1'}
********************
{1, 2, 3, 4, 5, 6, 7, 8, 9}
<class 'set'>
9
********************
{4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3}
{8, 9, 7}
********************
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{2, 3, 4, 5, 6, 8, 9, 10}