1.输出函数

print("hello world","hahaha",sep=",",end=".")
sep 间隔符
end 终止符

1.1 格式化输出 and 占位符

# 占位符
# %d 证书
print("hello%dworld" % 1)
# %s 字符串
print("hello%sworld %d" % (" hahaha ",1))
# %f 浮点 默认6位小数 四舍五入
print("hello%.2fworld" % 3.14)

# 格式化输出 f"{表达式{变量名}}"
hello = "hello"
print(f"{hello} 世界")

2.输入函数

input("请输入:")

3.变量赋值

aaa = 123
# 无需给出变量类型

4.数据类型

# 整形
n1 = 1
# 浮点型
n2 = 3.14
# 布尔型
n3 = False
# complex 复数型 固定写法 z = a + bj; a = 实部 b = 虚部 j = 虚数单位
n4 = 3 + 5j

4.1 检测变量类型的方法

type(param)

5.字符串

5.1 字符串的两种赋值方式

str1 = "zzzzz"
str2 = """
zzzzz
"""

5.2 字符串编码

5.3 编码和解码

a = "这是一个字符串"
print(a, type(a))
# 编码
b = a.encode() # a.encode("utf-8")
print("编码后:",b, type(b))
# 解码
c = b.decode() # a.decode("utf-8")
print("解码后:",c, type(c))

5.4 字符串运算符

5.5 字符串函数

a = "这是一一个字符串"
print(a.find("这")) # 返回存在的下标 否则返回 -1
print(a.count("一")) # 返回字符出现的次数
b = a.replace("一","二") # 将 字符串中的指定字符 替换成 指定字符
print(b)
print(a.split("一")) # 将字符串以 指定字符分割 成一个数组
print(a.index("字")) # 返回存在的下标 否则报错

c = "abcd"
print(c.startswith("a")) # 是否以 指定字符开头
print(c.endswith("d")) # 是否以 指定字符结尾

# 上面几个函数都可以指定 开始 和 结尾 如：
print(a.find("这",3,4))

print(c.capitalize()) # 第一个字母大写
print(c.lower()) # 大写转小写
print(c.upper()) # 小写转大写

6.运算符

6.1 算术运算符

6.2 比较运算符

• 大于 >

• 小于 <

• 等于 ==

• 不等于 !=

• 大于等于 >=

• 小于等于 <=

6.3 逻辑运算符

• and(与)

• or(或)

• not(非)

6.4 三元运算(三元表达式)

为真结果 if 判断条件 else 为假结果

a = 3
b = 2
print(a) if a > b else print(b)
结果：3

7.转义字符

8.判断(if-else,if-elif-else)

# if-else
if 00 == 0:
    print("相等")
else:
    print("不相等")

# if-elif-else
if 1==1 or 1==2:
  print(1)
elif 1<=1 and 1!=2:
  print(2)
else:
  print(3)

9.循环

9.1 for 循环

a = ["111","222","333"]

# range : 从0 到 输入的数,不包含结尾 range(1,10) 从1开始 到10结束,不包换10
for i in range (10):
    print(i)

9.2 while 循环

a = 3
while a < 5:
    print(a)
    a += 1

9.3 break continue

• break 结束循环

• continue 跳出当前循环轮次

10.集合

10.1 列表

# 列表
aa = ["a",1,"c",3.12,"e","f","g","h"]
# 添加
aa.append("h") # 在末尾添加
aa.insert(1,"i") # 指定下标添加
bb = [1,2,3,4]
aa.extend(bb) # 继承
print(aa)
# 获取
print(aa[3])
# 修改
aa[3] = "z" # 修改
print(aa)
print(aa[3:6]) # 切片
# 查找
print("3" in aa) # 存在
print("3" not in aa)  # 不存在
print(aa.index("z")) # 返回下标 不存在则报错
print(aa.count("3")) # 返回出现次数
# 删除
aa.remove("h") # 删除第一次出现的指定元素
aa.pop(1) # 删除指定下标
aa.pop() # 不给下标则默认删除列表中最后一个元素
# del aa 删除指定列表 也可以删除制定列表的指定下标
print(aa)
# 排序 如果全是数字则按照大小,字母或文字 按照自然排序,数字混字母 or 文字 则报错
# aa.sort() # 正序
# aa.reverse() # 逆序
print(aa)

10.1.1 列表推导式

# 列表
aa = ["a",1,"c",3.12,"e","f","g","h"]

# 列表推导式
[print(i) for i in aa]

bb = []
[bb.append(i) for i in range(1,25) if i % 2 == 0] # 只有能被2整除的才会被放入 列表中
print(bb)

10.1.2 列表嵌套

li = [1,2,3,[6,7,8]] # 列表嵌套指 一个列表中的某个元素 是一个列表
print(li[0])
print(li[3][2])
[print(i) for i in li if isinstance(i,list)] # 如果当前的值 为列表,则打印

10.2 元组

# 元组 tuple
# 元组一但创建,不支持增删改,只支持查询
tup = (0, 2, 3, 4, [5, 6, 7, 8, 9], (1, 2, 3))
[print(type(i)) for i in tup]

tub = (0,)  # 当元组只有一个元素的时候需要加上逗号,否则返回它唯一值的类型
print(type(tub))

# 取值 和正常的list 相同
print(tua[2])

# 一些list 函数也和list 一样 如 count len index [1:](切片)

# 应用场景
# 1.参数和返回值
# 2.格式化输出
tua = ("小明",18)
print("%s 今年 %d 岁了" % tua)
# 3.常量 让数据不可更改

10.3 字典

# 字典 类似于map 以键值对的形式出现
dic = {"b": 2, "c": 3, "d": 4, "e": 5}
# 新增 <-> 修改
dic['a'] = 1  # 存在key 则为修改, 不存在则新增
print(dic)
# 查询
print(dic.get("a", "不存在"))  # 如果a这个key不存在,则返回默认结果 “不存在” 默认值不填则返回 None
# 删除 指定key
dic.pop("a")  # key 不存在则报错
dic.popitem()  # 3.7之前 随机删除,之后默认删除最后一个键值对
del dic["b"]  # key 不存在则报错
# 删除字典
# del dic
# 清空
# dic.clear()
# 复制
dic1 = {"z": 90}
dic2 = dic1.copy()
# 将 update 中的字典添加到 调用方内,如果有冲突的key 则以update中的字典的值为主
dic1.update(dic)
# 或者是这种用法,有这个key 则修改,没有这个key 则新增
dic.update({1111:333,2222:444})
# 长度
print(len(dic))
# 返回所有的key
print(dic.keys())
# 返回所有的value
print(dic.values())
# 以元组形式返回所有的键值对
print(dic.items())

10.4 集合

# 集合 set -> 特点 无序 唯一
# 如果定义的是数字,则使用哈希表去排序使用自然选择排序;
# 如果定义的是其他类型,则每次运行结果都不同
# 声明 只能加入单独的元素
s1 = {1,2,3,''}
# 定义空集合
s2 = set()
s1.add("1")
s1.add("3")
print(s1)
# 查看hash值
print(hash("2"))

# set 样可以 使用 update remove pop discard ; 并且在更新操作时 只能加入单个元素,不能加入list 或是 其他集合类型
s1.update({"4","2"})
s1.discard("0")
print(s1)

10.5 交集和并集

# 交集 & 并集 |
# 交集：相交的元素 或者说 两个集合中都有的元素
# 并集：取全部的元素 去重
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
print(s1 & s2)
print(s1 | s2)
# 交集和并集 返回的都是集合类型
a = s1 & s2
print(type(a))
a = s1 | s2
print(type(a))

11.类型转换、深浅拷贝、可变对象和不可变对象

11.1 类型转换

# 类型转换
print(int('1'),type(int('1')))
# age = input("age:")
# if 18 <= int(age):
#     print("yes")
# else:
#     print("no")

print(float('1'),type(float('1')))
print(str({1,3,"9"}),type(str({1,3,"9"})))
print(eval('1'))
s1 = [1,2,3,4,5]
s1 = tuple(s1)
print(type(s1))
s1 = list(s1) # 转换列表只能选择可迭代对象 使用字典转换成list时,只会去key值
print(type(s1))
print(chr(1),type(chr(1)))

# eval 用来返回一个表达式执行之后的结果
print(eval('10+10'),type(eval('10+10'))) # 返回20
# eval 可以实现list dict tuple 和 str 之间的转换
st1 = '[1,2,3,[1,2,3]]'
print(eval(st1),type(eval(st1)))

11.2 深浅拷贝

# 深浅拷贝
# 直接赋值： 相同对象 完全共享，包括所有层次的子对象
s1 = [1,2,3,4,5,[1,2,3,4]]
s2 = s1
s1.pop(2)
print(s2)

# 浅拷贝： 不同对象 外层独立，但子对象仍然共享
import copy
s2 = copy.copy(s1)
s1[-1].remove(2)
print(s2)

# 深拷贝： 不同对象 完全独立，包括所有子对象
s2 = copy.deepcopy(s1)
s1[-1].remove(4)
print(s2)

11.3 可变(不可变)对象

# 可变对象 -> 存储空间保存的数据允许被修改 如 list dict set
# 不可变对象 -> 存储空间保存的数据不允许被修改 如 tuple int bool float complex str
# 对于不可变对象进行重新赋值时, 内存地址会出现修改
# 查看内存地址 ： id
li = [1,2,3]
print(id(li))
li.append(4)
print(id(li))

12.函数

1.函数的定义

# 定义函数时无需 定义入参类型 以及返回类型
def login(name):
    print("Logging in...")
    return "登录成功","name",name

int1 = login("2234")
print(type(int1),int1)

2.参数的类型

# 必备参数：在创建函数的时候声明了几个就需要传递几个
def test(aa,bb):
    return 1
# 默认参数：给某个参数默认值 -> 默认参数必须在非默认参数后面
def test1(aa,bb = 11):
    return bb
# 可变参数：将放在实参位置的参数使用元组的类型全部接受
def test2(*args):
    return args
# 关键字参数：接受所有的关键字参数使用字典接受
def test3(**kwargs):
    return kwargs

# 函数嵌套
def test4():
    print("这是第一层")
    def test5():
        print("这是第二层")
    return test5
# 如果想要直接在外部 调用test5 可以将test5 作为返回值,然后直接调用
func = test4()
func()

# 局部变量 and 全局变量
# 如果想要在函数内部修改全局变量的话 可以使用global
a1 = 100
def test1():
    global a1
    global a2 # 也可以直接在 函数中声明全局变量
    a2 = 100
    a1 = '120'
test1()
print(a1)
print(a2)

# nonlocal 修改外层的局部变量
def test2():
    a3 = 100
    def test3():
        nonlocal a3
        a3 = '120'
    test3()
    print(a3)

test2()

3.匿名函数

# 只适用于简单的表达式 复杂的表达式还是需要使用函数
a1 = lambda x, y: x + y
print(a1(1, 2))

a2 = lambda **kwargs: "a2 不为空" if kwargs is not None else "这是空的"
print(a2(a1=1, a2=2))

4.内置函数

# 查看所有的内置函数
import builtins
print(dir(builtins))

['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

内置常量

• True, False, None - 布尔值和空值

• Ellipsis / ... - 省略号对象

• NotImplemented - 表示操作未实现

内置异常类

基础异常类：

• BaseException - 所有异常的根类

• Exception - 常规异常的基类

• Warning - 警告的基类

具体异常类型：

• ArithmeticError - 算术错误

• ZeroDivisionError - 除零错误

• TypeError - 类型错误

• ValueError - 值错误

• IndexError - 索引错误

• KeyError - 键错误

• NameError - 名称未定义

• AttributeError - 属性错误

• SyntaxError - 语法错误

• ImportError - 导入错误

• FileNotFoundError - 文件未找到

• 等等...

常用内置函数

数学运算：

• abs(x) - 绝对值

• pow(x, y) - 幂运算

• round(x) - 四舍五入

• divmod(a, b) - 返回商和余数

• max(), min() - 最大/最小值

• sum() - 求和

类型转换：

• int(), float(), bool() - 数值转换

• str(), bytes(), bytearray() - 字符串/字节转换

• list(), tuple(), dict(), set() - 容器类型

• chr(), ord() - 字符编码转换

• bin(), oct(), hex() - 进制转换

迭代和序列：

• len() - 长度

• range() - 生成序列

• enumerate() - 添加索引

• zip() - 并行迭代

• reversed() - 反转序列

• sorted() - 排序

• all(), any() - 逻辑判断

对象操作：

• id() - 对象标识

• type() - 对象类型

• isinstance(), issubclass() - 类型检查

• callable() - 是否可调用

• hasattr(), getattr(), setattr(), delattr() - 属性操作

输入输出：

• print() - 输出

• input() - 输入

• open() - 打开文件

代码执行：

• eval() - 执行表达式

• exec() - 执行代码

• compile() - 编译代码

其他重要函数：

• help() - 帮助信息

• dir() - 查看属性

• globals(), locals() - 命名空间

• iter(), next() - 迭代器操作

• super() - 调用父类

• property() - 属性装饰器

• classmethod(), staticmethod() - 方法装饰器

特殊变量

• __name__ - 模块名称

• __debug__ - 调试模式

• __doc__ - 文档字符串

• __import__ - 导入函数

5.拆包

tua = (1,2,3)

# 要求元组中的元素个数 和 接受的变量个数相同
a,b,c = tua
print(a,b,c)
# 第二中方式,可变参数
a,*b = tua
print(a,b)

13.异常

后面的东西没了，数据库被黑了，懒得再写一遍了，就这样吧！