Python第一天

# 注释
# 单行注释
'''
    多行注释
    多行注释
    多行注释
'''

"""
    多行注释
    多行注释
    多行注释
"""

# 变量
# 命名
'''
    变量的定义要求:
        1.命名要求： 字母、数字、下划线
        2.注意: (1)数字不能作为开头
               (2) 不能以关键字作为变量名
'''
i = 'hello world'
print(i)

# 关键字
import keyword
'''
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'
'''
print(keyword.kwlist)

# 变量定义
# 定义即赋值，定义的时候不需要去指定数据的类型，
# Python执行器可以自动判断
var1 = "word"
print(var1, type(var1))

var1 = 1
print(var1, type(var1))

# print函数
print(1, 2, 3, 4)
print("hello", end='')
print("world")

# 5种基础数据类型
'''
    整型: int
    字符串: str
    小数: float
    布尔类型: bool
    空类型:NoneType

注意：
    1.bool类型中的True和False是需要首字母大写
    2.变量类型可以自动去判断
    3.字符串中单引号和双引号不区分
'''
# 整型
var1 = 1
print(var1, type(var1))

# 字符串
var1 = "str"
print(var1, type(var1))

var1 = 'str'
print(var1, type(var1))

# 小数类型
var1 = 1.1
print(var1, type(var1))

# 布尔
var1 = True
print(var1, type(var1))

# 空类型
var1 = None
print(var1, type(var1))

# 类型之间的相互转换

# 从字符串转换成int类型
# 字符串转换成int
s = '1'
print(int(s), type(int(s)))
#------------1 <class 'int'>
# 字符串转换成浮点型
s1 = "1.1"
print(float(s1), type(float(s1)))
#------------1.1 <class 'float'>
# float转换成int类型
f1 = 3.14
print(int(f1), type(int(f1)))
#------------3 <class 'int'>
# 丢失精度时 不会去做四舍五入
f1 = 3.6
print(int(f1), type(int(f1)))
#------------3 <class 'int'>
# 数值0 转换成bool类型时 会默认转换成False
# 数值1 转换成bool类型时 会默认转换成True
b = 0
print(bool(b), type(bool(b)))
#------------False <class 'bool'>
b = 1
print(bool(b), type(bool(b)))
#------------True <class 'bool'>
b = 3
print(bool(b), type(bool(b)))
#------------True <class 'bool'>
print(">" * 50)
# 字符串的常见操作
str1 = "java Python scala sql"

# split 切分
str2 = str1.split(" ")
print(str2, type(str2))
#-------------['java', 'Python', 'scala', 'sql']
#----------------<class 'list'>
# strip 去除字符串两边的隐藏字符
# \t 表示一个制表符
# \n 表示换行
# \r 表示回车
str3 = " \t \n java Python scala sql \t \n \r"
print(str3)
str4 = str3.strip()
print(str4, type(str4))

# 字符串的切分
# 规则：[开始位置:结束位置:步长]
# 开始位置是从0开始 结束位置不包含
# 即 取值区间是一个左闭右开区间 [开始位置:结束位置)
#
#包含头不包含尾
print(str1[5:11])
#--------------Python
# 步长：从第5个字母开始取值，到第11个字母为止（不包含11），间隔为2（5+2<11）
print(str1[5:11:2])
#--------------Pto
# 反转
print(str1[::-1])
#------------lqs alacs nohtyP avaj
# 反转Python
# 负值取值是从后往前数
print(str1[-11:-17:-1])#Python

# 获取字符串长度
print(len(str1))#21

# 字符串中的索引
print(str1[0])#j

# 格式化
a = 10
b = 3
print(a, ' * ', b, ' = ', a * b)

# 方式一
str_format = "{} * {} = {}"
print(str_format.format(a, b, a * b))

# 方式二
# %d 表示 数字
# %s 表示 字符串
# %f 表示 浮点型
# %.nf 表示 输出小数点后n位
print("%d * %d = %d" % (a, b, a * b))
print("%s * %d = %d" % ('4', b, a * b))
print('%f' % 3.14)
print('%.1f' % 3.14)

# 算术运算符
# + - * / % // **
# Pycharm 快捷键 Ctrl + D 表示复制当前行至下一行
# // 表示整除 ** 表示次方
a = 10
b = 3
print(a + b)  # 13
print(a - b)  # 7
print(a * b)  # 30
print(a / b)  # 3.33333...
print(a % b)  # 1
print(a // b)  # 3
print(a ** b)  # 1000

# 如果是两个 ** 号 则需要从后往前计算
print(2 ** 3 ** 2)  # 512
# 如果是两个 // 号 则需要从前往后计算
print(10 // 3 // 2)  # 1

 

# Python的数据容器，Java中的集合(Collection)
'''
    1.列表 List
    2.元组 tuple
    3.集合 set
    4.字典 dict
'''

# 列表 list
# 定义: 用[] 定义一个list
'''
    特点:
        1.可以存储不同类型的数据
        2.可以存储相同数值数据
        3.存储数据内容是有序的
        4.列表中的元素是可以被删除的 
        5.列表中可以嵌套列表
'''
list1 = [1, 1, 2, 3, 1.1, True, "str"]
print(list1)

# 取元素
# 通过索引(index)取值,从0开始取值
print(list1[0])

# 切片
# 规则:[开始位置:结束位置:步长]
print(list1[::])
# 反序列取值
print(list1[::-1])

# 修改元素
list1[2] = "A"
print(list1)

# 删除元素
# pop方法：删除列表中最后一个元素
list1.pop()
print(list1)

# remove：删除列表中指定的值，如果出现重复，那么就删除第一个出现的值
list1.remove(1)
print(list1)

# 增加元素
# append:在列表的末尾进行追加元素

list1.append([1, 2])
print(list1)

# insert:在列表的指定索引位置插入元素
list1.insert(4, False)
print(list1)
print("^"*50)
# 其他函数
# 排序
list2 = [3, 4, 1, 2]
list2.sort()
print(list2)#1234
print(list2[::-1])

# 合并
# extend函数：讲另外一个列表追加到当前列表之后
list3 = [6, 7, 8, 9]
list1.extend(list3)#list3加到list1的末尾
print(list1)

# +: 将两个list 合并成一个新的 list
list4 = list2 + list3
print(list4)#12346789

# 反转
list4.reverse()
print(list4)#98764321

# 统计
list5 = [1, 1, 2, 3, 1]
print(list5.count(1))#3

# 清除
list5.clear()
print(list5)#[]

# 元组
# 定义 通过() 进行定义
'''
    特点：
        1.可以存储重复数据
        2.可以存储不同类型的数据
        3.元组是有序的
        4.元组是不支持修改
        
'''
print('>>>>' * 40)
tuple1 = (1, 1, 2, 3, 1.1, True, "str")
print(tuple1)

# 取元素
print(tuple1[3])#3

# 改变元素
# tuple1[3] = "A"
# print(tuple1)#报错：元组不支持修改

# 其他方法
# count:统计
print(tuple1.count(1))

# set 集合
# 定义 set集合使用{}
'''
    特点：
        1.set集合可以存储不同类型数据
        2.set集合是无序的
        3.set集合存储不了重复数据
'''

set1 = {1, 1, 2, "hello", False, 1.1}
print(set1)

# 取元素
# set集合不能通过下标进行取数据
# print(set1[2])
for i in set1:
    print(i)

# 删除数据
set1.pop()
print(set1)

set1.remove("hello")
print(set1)

# 增加元素
set1.add(1)
set1.add(2)
set1.add(3)
print(set1)#数据输出不重复

# 集合运算
set2 = {2, 3, 4}
set3 = {3, 4, 5}
print(set2 & set3)  # {3,4}
print(set2 | set3)  # {2,3,4,5}
print(set2 - set3)  #{2} -号是指去除set2中set2与set3重复的元素

# 字典
# 定义：{K:V}----中间冒号分隔开
'''
    特点：
        1.不可以存储相同Key的数据，默认存储后一个相同Key的Value值
        2.需要通过Key进行取值
        3.当Key中出现0和TRUE以及1和False后会出现相同key替换现象(特点1)
        4.字典中的Key为不可变元素,Value中可以存储任意类型元素（不能List：因为list可变）
        5.字典中的Value值可以直接根据类型取出
        6.查询速度并不会随着元素的增多变慢

'''
dict1 = {
    'x1': "x1",
    'x1': "x2",
    1: "1",
    0: "0",
    True: "true",
    False: 'false',
    (1, 2, 3): "tuple(1,2,3)",
    # [1, 2, 3]: "list[1,2,3]",
    "xx1": [1, 2, 3],
    "xx2": {
        "xxx1:": "vvv1",
        "xxx2": {"xxxx1": "4x1"}
    }
}
print(dict1)

# 取元素
# 无法通过下标index进行取值
# print(dict1[2])

# 通过Key进行取值
# 方式一：
print(dict1['x1'])
# 方式二：
dict1.get("x1")

# 改变Key对应的Value值
dict1['x1'] = 'x3'
print(dict1)

# 常规操作
print("所有keys:", dict1.keys())
print("所有values:", dict1.values())
print("所有k-v:", dict1.items())

# 扩充字典
print(dict1)

# 取嵌套字典值
print(dict1.get('xx2').get('xxx2').get('xxxx1'))

# 遍历容器
'''
    1.列表 List
    2.元组 tuple
    3.集合 set
    4.字典 dict
'''
# 遍历列表
ls1 = [3, 4, 5]
for i in ls1:
    print(i)

# 遍历元组
tup1 = (3, 4, 5)
for t in tup1:
    print(t)

# 集合Set
set4 = {4, 4, "hello", True}
for s in set4:
    print(s)

# 字典dict
dict2 = {
    'xx1': "xx1",
    'xx2': "xx2",
    'xx3': "xx3",
}

for key in dict2.keys():
    print(key)

for values in dict2.values():
    print(values)

for kv in dict2.items():
    print(kv[0], kv[1])

for k, v in dict2.items():
    print(k, v)


# range 函数
# range 传值是一个区间，区间是左闭右开区间，
# 起始位置如果是0 可以不写
for i in range(10):
    print(i)#0123456789

# 步长
for j in range(1, 10, 2):
    print(j)#13579

# 需求：获取一个从1...100的列表
# 方式一:
list6 = []
for i in range(1, 101):
    list6.append(i)
print(list6)
#list集合是添加元素append，set集合是add
# 方式2:
# 列表推导式
list7 = [i for i in range(1, 101)]
print(list7)

# 需求：获取一个从1...100的奇数列表
# 方式一：
list7 = [i for i in range(1, 101, 2)]
print(list7)

# 方式2:
# 列表推导式：第一个i是列表用于存放第二个i的值
list7 = [i for i in range(1, 101) if i % 2 == 1]
print(list7)

# join 和 split
str2 = "java,python,scala"
print(str2.split(','))
list8 = str2.split(',')
print(','.join(list8))

# 九九乘法表
print("\n".join(['\t'.join(['{} * {} = {}'.format(j, i, j * i) for j in range(1, i + 1)]) for i in range(1, 10)]))