Python基础

为方便运行， 以下所有代码， 带input的块， 整体注释

import copy

# ctrl + / 为注释或取消注释

# 输出语句print
print(1, 3)
print(1, 2, end='/')
print(1, 2, 3,  sep='/')

# 输入语句 input
# num为变量名
# num =  input("input:")
# print(num)

# 整型 (int)
two = 2

# 查看类型
print(type(two))

# 浮点数/小数 (float)
four = 4.11
print(four)
print(type(four))

"""数值类型转换"""
print('----------------')
print(float(two))
# 把小数转换成整数会舍弃小数位，若想四舍五入+0.5
print(int(four))

"""数值运算"""  # 小数整数运算，最终结果为小数
print(two == four)
print('-----------------')
print(two + four)
# 取余， 取整， 取幂
print(four % two)
print(10 % 3)
print(10 // 3)
print(10 ** 3)

"""赋值运算发"""
# += -= ......

"""字符串类型"""
# 字符串中有单引号，就用双引号包括，如果有双引号，就用单引号包括，三引号是用来换行
s1 = 'he“l”lo world'
s2 = "h‘e’llo"
s3 = """
he
"""
print(s1)
print(s2)
print(s3)

# 字符串三种格式化方式
# 数字与字符不能直接相加拼接
name = '张三'
age = 18
nickname = '法外狂徒'
print('姓名：' + name + '， 年龄：' + str(age) + '， 外号' + nickname)

print("--------------------------------")

"""字符串格式化， format 用{}占位, 不需要转换，直接可以拼接， 指定内容占位传参即可"""
print("姓名：{}, 年龄：{}, 外号{}".format(name, age, nickname))
print("--------------------------------")
# 另一种方法
format_str = '姓名：{}, 年龄：{}, 外号{}'
print(format_str.format(name, age, nickname))

"""%s 用%s进行占位"""
print("----------%s-------------")
print("姓名：%s, 年龄：%s, 外号：%s" % (name, age, nickname))

"""f, 往字符串中插入变量， 好处：简单， 坏处：不能复用字符串模板"""
print("-------f----------")
print(f"姓名：{name}， 年龄：{age}, 外号：{nickname}")

"""for"""
format_str1 = 'asjdfklj{}'
str1 = 'asd%s'
for i in range(10):
    print(i)
    print(format_str1.format(i))
    print(str1 % i)
    print(f'aaaa{i}')

"""去除字符串两端的空白（默认）字符strip()，可以指定去除字符串"""
# 字符串是一种不可变的序列类型，字符串方法大多数都是返回一个新的字符串
s = '\nasdfasdf'
print(s)
print(s.strip())
# 指定去除
print(s.strip('f'))
# 链式调用，可以叠加
print(s.strip('f').strip('d'))

"""replace 替换字符串"""
print(s.replace('asd', 'aaaaaaa'))

"""split 字符分割，默认以空白字符进行分割，也可指定"""
arr = '1 2 3 4\n5'
print(arr.split())
print(arr.split('3'))

"""join合并， 把一个分割之后的列表合并为字符串"""
arr1 = ['1', '2', '3']
print("".join(arr1))
print(" ".join(arr1))
print(",".join(arr1))

"""转义字符"""
# \是一个转义字符串， 换行符是看不到的， \（看不到换行符） 可以实现跨行
print("hello \
world ")
print("hello \\ world")
"""
一个反斜杠不是反斜杠，是特殊字符， 两个反斜杠才是斜杠， %和=同理
\n 换行符
\t 制表符 tab 补齐四个空格
"""

"""原始字符串，禁止转译"""
print(r"hello \\ world")

"""----------------数据类型-----------------------"""

"""布尔类型"""
ture = True
false = False
print(4>5)
"""布尔类型转化"""
print('---------除0以外其余数字都是true-------------')
print(bool(0))
print(bool(-1))
print(bool(1))
print(bool(2))

print('--------空字符串为false, 其余为true')
print(bool(""))
print(bool(" "))
print(bool("asdf"))
print("---------------None为False, 其余类型为true---------------")
print(bool(None))
print(bool(int))
print(bool(float))

if 4 > 5:
    print("4>5")
else:
    print("4<5")

"""and, or, not（真变假， 假变真）运算符略"""

"""成员运算符"""
print("--------字符串是否存在其中---------")
two = '2'
temp = '1234'
print(two in temp)

"""身份运算"""
print("------身份运算is， 在判断数字与字符串时会失效")
one = 1
one1 = 1
print(one is one1)
o1 = '1'
o2 = '1'
print(id(o1), id(o2))   # 字符串地址相同 ， 数字地址相同， 但列表地址不同， 因内存驻留机制，前两者失效， 列表为容器
one_1 = [1]
one_2 = [1]
print(one_1 == one_2)       # 判断值是否相等
print(one_1 is one_2)       # 判断两个是不是一个id地址

print(id(one_2), id(one_1))

"""if else"""
light = "red"

if light == 'red':
    print("stop")
elif light == "green":
    print("go")
else:
    print("yellow")

"""运算符优先级：指数、乘除取余取整取模、位运算、比较运算符、等于运算、赋值运算、身份、成员、逻辑"""

"""while"""
i = 0
while i < 5:
    print("12")
    i+=1

i = 1
while i <= 5:
    print(i, "*"*i)         # 字符串可以进行加法和乘法运算
    i += 1

"""for遍历"""

for i in "hello":           # for会从字符串里面将字符一个个遍历出来, for在遍历内容的时候， 只要是容器(字符串、列表、元组、集合、字段。。。)， 就可以将里面的内容全部取出来
    print(i)

i = 1
temp_str = "hello"
while i < len(temp_str):
    print(temp_str[i])
    i+= 1

print("---------------------------------------------------")

for i in range(0, len(temp_str)):     # 这个是for循环，上面的是遍历
    print(temp_str[i])

# range 是一个生成器， 装元素的
"""range(start, stop[, step])"""
print(list(range(0, 9, 1)))     # 从0开始， 不长为1， 到9


"""break"""
# while True:
#     password = input("input password:")
#     if password == "123":
#         print("right")
#         break     # continue同理
#     print("error")

"""for - else结构、while - else结构"""
for i in range(0, 5):
    print(i)
    if i == 3:
        break
else:
    print("for语句正常执行完毕， 才会进else")

"""三元表达式"""
# a = int(input("input a:"))
# b = int(input("input b:"))
# max_num = a if a > b else b         # a>b, 则为结果a， 否则为结果b
# print(max_num)

"""列表是一种可变的， 有序的数据结构， 可以随时添加和删除其中的元素"""
# 列表可以存放多种数据
arr = [1, 2, 3, 4, 5, 6, 7]
arr1 = [1, 2, 3, '4', bool, int, arr]   # bool, int 都是对象
print(arr1)

"""转化其他的容器为列表"""
print(list('123'))
# 列表是可变的
arr[0] = '0'
print(arr)

"""列表可以逆序取值， -1是最后一个元素， 依次-2、-3向前"""

"""列表切片"""
print(arr[1:3])     # 同样取不到最后一个元素
# 想取到最后一个， 可以省略最后一个， 如果开始省略， 从第一个开始取
print(arr[0:])
print(arr[0:-1:2])      # 从0取到倒数第二个， 步长为2

print("----------------------------------------------")

"""元组 不可变的序列类型 tuple"""
tpl = (1,2, 3, 4, 5)
print(tpl)
tpl2 = tuple('hello')           # 强制转换为元组
print(tpl2)
# 元组是一个不可变的序列类型，不可以修改， 序列类型都可以切片， 如果元组中只包含一个元素， 那么在定义过程中加逗号
# 元组不可修改， 所以同样不可对元组中元素进行删除， 但是可以对整个元组删除
tpl3 = (1)
tpl4 = (1,)
print(tpl3, tpl4)

"""二维列表"""
arr1 = [[1, 2, 3, 4], ['a', 'b'], (1, 2, 3)]

"""列表的常用方法，增删改查"""
arr = [1, 2, 3, 4, 5]
arr.insert(0, '0')          # 会插入到指定的元素前面去
print("列表：------------------------------------", arr)
# append 添加元素至列表末尾
arr.append('6')
print(arr)
# pop 默认弹出列表的最后一个元素, 可以指定弹出元素的索引， 会把弹出的元素返回回来
arr.pop()
print(arr)
value = arr.pop(2)
print(arr)
print(value)
# remove 指定元素删除, 如果内容不存在， 报错， 无返回值
arr.remove(3)
print(arr)
# del python系统删除方法

print('---------------------------------')

arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr3 = arr1 + arr2
con = []
print(arr3)
arr1.extend(arr2)   # 往列表中追加一个列表， 连在后面
print(arr1)
arr2.append(arr1)   # 将列表当成元素添加进去, 也用来合并两个数组
print(arr2)
for i in range(3):
    con.append([arr1[i], arr2[i]])
print(con)
"""index 获取指定元素所在的位置"""
print("---------index---------------")
print(arr1.index(2))

"""字典(dict)：可变的， 无序的， 键值对的， 复杂的数据容器, 字典可以嵌套字典"""
"""无序的， 所以不可通过下标取值"""
dict1 = {
    "name":'ming',
    "age": 18,
    "gender": True,
    "height": 180,
}
dict2 = {       # 数字、 元组、 字典等均可作为健， 但是列表（列表为可变的数据类型）不可
    1: 1,
    (1,): (1,),
    'list': [1, 2, 3, 4],
    'dict': {
        "name":'li',
        "age": 18,
        "gender": True,
        "height": 180,
    }
}
"""键值对是数据结构， 所以可以修改键值， 输出时如果健不存在就会报错， 可追加键"""
print(dict1['name'])
dict1['name'] = 'mmming'
print(dict1['name'])
dict1['name1'] = 'mmmmm'        #健不存在， 追加一个健
print(dict1)
# 取字典中的字典健
print(dict2['dict']['name'])        #一层一层往下取， 若字典中的字典是列表， 还需要取列表后再取健
# 不清楚字典中给有没有这个值， 用get方法， 没有默认返回None, 或者自己设置返回什么， 有就返回值
print(dict1.get('name2'))
print(dict1.get('name2', '未命名'))
print(dict1.get('name'))
print("-------------------------------")
# 获取所有的健、值、键值对
print(dict1.keys())
print(dict1.values())
print(dict1.items())
print('------遍历键值对-----------------')
for key in dict1.keys():
    print(key, dict1[key])
print('---------遍历值， 不能通过值获取健--------------')
for value in dict1.values():
    print(value)

dict11 = {
    "name":'ming',
    "age": 18,
    "gender": True,
    "height": 180,
}
dict12 = {
    'name': 'mi',
    'age': 18,
    'hobby':['eat', 'drink']
}
# 把一个字典更新到另一个字典中
dict11.update(dict12)
print(dict11)

"""---------------------------set 集合---------------"""
# 集合：一种无序的、可变的、 不可重复的数据类型
# 集合用{}创建， 一般用作于去重
print('--------------------------set 集合--------------------------')
s = 'hello, world'
set1 = set(s)
set1.add(1)     # 增加集合中的元素
print(set1)
# 集合打印没有重复的， 那么可以用来给列表去重
set2 = {1, 2, 3, 1, 2, 3}
list10 = [1, 2, 3, 4, 5, 6, 7, 8, 2, 3, 4, 5]
list100 = list(set(list10))
print(list100)

"""集合运算"""
set3 = {2, 3, 4}
set4 = {3, 4, 5}
# 交集 and &
print(set3 & set4)
# 并集 or |
print(set3 | set4)
# 异或集
print(set3 ^ set4)

"""函数：封装了一段可被重复调用的代码块"""
print("-----------------------------函数----------------------------")

def func():     # 定义函数      不能以数字开头， 不能用关键字
    print("hello")
    # return 函数的返回结构，默认为none
    return None
    # return 'asdf'

# 调用函数才会享受到封装的效果
# 调用的方法 函数名 + ()
re = func()
print(re)
# 带参数的函数
def get_max(num1, num2):
    num3 = 0
    if num1 > num2:
        num3 = num1
    else:
        num3 = num2
    return num3
print(get_max(1, 2))
# 为防止参数顺序错误， 可用给关键字参数, 指定参数， 但位置参数一定要在关键字参数前面， 否则会报错
print(get_max(num2=1, num1=4))
print(get_max(1, num2=5))

# 默认参数：定义函数的时候给参数设置默认参数
# 当函数在调用的时候没有传递参数， 就会使用默认参数， 如果传递了参数， 就会覆盖掉默认参数
def f1(x, k=5, b=6):
    y = k * x +b
    return y
print(f1(5))
print(f1(5, 6, 7))

"""*argus 使用*收集位置参数，以应对参数有很多个， 未知个数 argus是变量"""
def get_sum(*args):
    total = 0
    for arg in args:
        total += arg
    print(args)
    return total

print(get_sum(190, 292, 292))

# 若要带关键字， 则用以下
def get_sum(*args, **kwargs):       # ** 使用**收集关键字参数
    # *args **kwargs 组合起来可以接受任意的函数
    total = 0
    for arg in args:
        total += arg
    print(args)
    print(kwargs)
    for kwarg in kwargs.values():
        total += kwarg
    return total

print(get_sum(190, 292, zs=292))

def print_(arg):
    print(arg, sep="", end="")

def changed_print(*args, sep=' ', end='\n'):
    # 遍历接收到的所有元素， 在打印每个元素后加空格
    for arg in args[:-1]:       # 为了让最后一个元素输出后面没有空格， 使用切片， 让最后一个不输出
        print_(arg)
        print_(sep)
     # 把最后一个元素放在外面打印
    print_(args[-1])
    print_(end)
changed_print(1, 2, 3, 4, 5)

arr = [['s', 3], ['a', 5], ['b', 2]]

def func(temp):
    print('temp', temp)
    # 默认是用列表的元素进行排序
    return temp[1]
# key 列表的排序规则， 必须传入一个函数对象
# 在列表进行排序的时候会自动调用
arr.sort(key=func)      # 用key=func自定义排序方式
print('------')
for a in arr:
    print(a)


"""全局变量、局部变量"""
num = 2
def foo():
    # 函数里面可以直接调用全局变量
    # 函数内容是局部变量， 局部变量优先级高于全局变量
    global num  # global 可以在局部变量内部声明一个全局变量， 但是尽量不要使用global
    print(num)  # 在局部变量内部修改全局变量， 默认会报错
    num = 5
    print(num)

foo()

"""文件操作"""
"""
file: 文件名， 需要操作的文件
mode: 操作模式
        w write 写入          # 覆盖写入, 不可恢复
        r read 读取
        a append 追加写入      # 不会覆盖
        
写入操作时， 只能写字符串，不能其他
    
"""
file = open(file='hello.txt', mode='r', encoding='utf-8')       # 打开一个文件
# file.write('hello world')                                       # 往文件里面写入数据
# text = file.read()              # 读取全部
txt = file.readline()           # 读取一行
file.close()                                                    # 关闭一个文件
# print(text)
print('----------------')
print(txt)

# with 关键字 上下文管理器， 当不在with语句里面的时候， 会自动关闭文件
# as 重命名 起别名file, 使用file 指代open 打开的文件
with open(file='hello.txt', mode='r', encoding='utf-8') as file:
    line = file.readline()  # 读取一行
    print(line)
    lines = file.readline() # 读取多行， 是一个列表
    print(lines)

# """异常处理, 目的时为了， 即便出现错误， 也继续向下运行"""
# num111 = input('请输入一个数字:')
# total = 0
#
# # 尝试去做某件事情
# try:
#     total += 5 # 正常运行
#     total += int(num)   # int(‘s')
#     total += 5
# # 如果尝试失败， 就捕获异常
# # except Exception as e:      # 所有错误都会异常
# #     print(e)
# #处理专门的错误
# except ValueError as e:
#     print('值错误', e)
# except ZeroDivisionError as e:
#     print('被除数不能为零', e)
# print(total)

"""深拷贝， 对象引用"""
# 使用=赋值（对象引用）
# =赋值：数据完全共享

arr112 = [1, 2, 3, 4]
# 把arr112 赋值给arr119
# 直接赋值是对象引用， 对象引用会共享数据
arr119 = arr112
arr119[0] = 0
print('arr112', arr112)
print('arr119', arr119)

"""浅拷贝"""
arr9 = [1, 2, 3, 4]
# 把arr112 赋值给arr119
# 直接赋值是对象引用， 对象引用会共享数据
arr8 = arr9.copy()
arr8[0] = 0
print('arr8', arr8)
print('arr9', arr9)

"""浅拷贝只会赋值一维数据"""
arr9 = [1, 2, 3, 4, [5, 6, 7]]
# 把arr112 赋值给arr119
# 直接赋值是对象引用， 对象引用会共享数据
arr8 = arr9.copy()
arr8[-1][-1] = 0
print('arr8', arr8)
print('arr9', arr9)

"""深拷贝， 会把所有的内容全部复制一份"""
arr9 = [1, 2, 3, 4, [5, 6, 7]]
# 把arr112 赋值给arr119
# 直接赋值是对象引用， 对象引用会共享数据
arr8 = copy.deepcopy(arr9)      # 最前面引入包， import copy
arr8[-1][-1] = 0
print('arr8', arr8)
print('arr9', arr9)