Python

数字（Number）

int

float

complex

以 j 结尾的表示复数

bool

字符串（string）

字符串定义

name1 = 'zsy'

name2 = "whx"

name3 = """nb"""

name4 = '\'666'\'

注释

单行注释

# 内容

多行注释

"""
内容
"""

变量及其赋值

name = "whx"

验证数据类型（type）

type1 = type(name)

print(type1)

变量是没有类型的，变量存储的数据有类型

数据类型转换

# 转换为int类型
int()

# 转换为string类型
str()

# 转换为float类型
float()

万物皆可转换为string，并不是万物皆可传为int和float

标识符命名

只允许有英文、中文、数字和下划线，数字不可开头

运算符

算术运算符

运算符	描述	实例
+	加
-	减
*	乘
/	除
//	取整除
%	取余
**	指数	2**3 = 8

赋值运算符

=

赋值

复合赋值运算符

+=
-=
*=
/=
//=
%=
**=

字符串扩展

字符串拼接

address1 = "北京"

address2 = "上海"

# +只能拼接str类型的
print("我去过" + address1 + address2)

字符串格式化（%s）

name = "whx"
message = "我叫%s" %name
print(message)

%s	将内容转换为字符串，放入占位位置
%d	将内容转换为整数，放入占位位置
%f	将内容转换为浮点型，放入占位位置

who = "I"
time = 2.5
name = "cxk"
message = "大家好，%s是联系时常%f的偶像练习生%s" % (who, time, name)
print(message)

格式化浮点型精度控制

%(m.n)d/f

m为宽度

n为小数点后几位，四舍五入

who = "I"
time = 2.5
name = "cxk"
message = "大家好，%s是联系时常%.1f的偶像练习生%s" % (who, time, name)
print(message)

格式化 -快速

who = "I"
time = 2.5
name = "cxk"
message = f"大家好，{who}是练习时常{time}的偶像练习生{name}"
print(message)

不做精度控制，原本什么样就是什么样

表达式格式化

表达式就是有明确执行结果的代码

用户输入（input）

Python判断语句

true为1，false为0

比较运算符

运算符	描述	例
==	内容是否相等
!=	内容是否不相等
>
<
>=
<=

if

if age = 1:
    print("666")

数据容器

序列

list tuple str

序列

目录

数字（Number）

int

float

complex

bool

字符串（string）

字符串定义

注释

单行注释

多行注释

变量及其赋值

验证数据类型（type）

数据类型转换

标识符命名

运算符

算术运算符

赋值运算符

复合赋值运算符

字符串扩展

字符串拼接

字符串格式化（%s）

格式化浮点型精度控制

格式化 -快速

表达式格式化

用户输入（input）

Python判断语句

比较运算符

if

数据容器

序列

序列

切片

倒序

元组

下标获取元素

index()

count()

len()

str

replace()

spilt()

strip()（去除头和尾的空格）

count()

len()

set(集合)

add()

remove()

pop()

clear()

difference()

difference_update()

union()

len()

for in遍历

---

切片

从大的序列中取出一部分

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

a[2:5]

[初始下标:结束下标(不含最后一个):步长]

初始下标可以为空，结束下标也可为空

倒序

[::-1]

元组

一旦定于，无法修改

tuple = ((1, 2), (3, 4, 5), (6, 7, 8))

下标获取元素

tuple[1][1]

index()

tuple = ((1, 2), (3, 4, 5), (6, 7, 8))

num = tuple.index()
print(f"{num}")

count()

计算传入值出现的次数

tuple = (1, 1, 1, 2, 3, 4, 2, 1)

num = tuple.count(1)

print(f"{num}")

len()

元素个数

str

和元组一样不可修改的容器

replace()

str = "today is sunny and hot"

new_str  = str.replace("sunny", "rainy")

print(new_str)

替换之后为新字符串

spilt()

根据给定的元素分割字符串称为列表

str = "today is sunny and hot"
list = str.split(" ")
print(f"{list}")

strip()（去除头和尾的空格）

count()

len()

set(集合)

set() 空集合

不支持重复，无序

set = {1, 2, 3, 4, 5, 6, 7, 6, 45, 3, 1, 2, 1}

不支持下标访问

add()

set = {1, 2, 3, 4, 5, 6, 7, 6, 45, 3, 1, 2, 1}
set.add(a)
print(set)

remove()

set = {1, 2, 3, 4, 5, 6, 7, 6, 45, 3, 1, 2, 1}
set.remove(1)

pop()

随机取一个元素

set = {1, 2, 3, 4, 5, 6, 7, 6, 45, 3, 1, 2, 1}
new = set.pop()
print(f"{new}")

clear()

清除完之后为一个空集合set()

difference()

集合1中集合2没有的元素

set1 = {1, 23, 34}
set2 = {1 , 23, 3}
set3 = set1.difference(set2)
print(f"{set3}")

difference_update()

删除集合1中以集合2共有的元素

set1 = {1, 23, 34}
set2 = {1 , 23, 3}
set1.difference_update(set2)
print(f"{set1}")

union()

合并集合

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1.union(set2)
print(f"{set3}")

len()

用for in遍历

dic（字典）

my_dic = {
    "whx" : 22,
    "zsy" : 18        
}

# 定义空集合
my_dic2 = {}
my_dic3 = dict()

key-value 键不能重复，后来的键覆盖掉前面的键

my_dict = {"whx" : 22, "zsy" : 18}

age = my_dict["whx"]

print(f"{age}")

dict嵌套

my_dict = {
       "one" : {"whx" : 22, "zsy" : 18}, 
       "two" : {"wyy" : 23, "lili" : 18}
}

age = mydict["one"]["zsy"]

print(f"{age}")

新增 更新

my_dict = {"whx" : 22, "zsy" : 18}
# 更新
my_dict["whx"] = 23
# 新增
my_dict["lili"] = 18

pop()

my_dict = {"whx" : 22, "zsy" : 18}
name = my_dict.pop("whx")
print(f"{name}")
print(f"{my_dict}")

clear()

my_dict.clear()

print(f"{my_dict}")

keys()

keys = my_dict.keys()
print(f"{keys}")

遍历

for key in my_dict:
    print(f"{my_dict[key]}")

len()

通用操作

max()

min()

sorted()

排序的结果为list

反向排序

sorted(my, reverse=True)

类型转换

list()

tuple()

str()

set()

函数进阶

多返回值

def test():
    return 666, "whx", "zsy"

a, b, c = test()
print(f"{a}")
print(f"{b}")
print(f"{c}")

多个变量接收多个返回值

多种参数

# 第一种（常规）
def test1(name, age):
    print(f"{name},{age}岁了")

test1("whx", 20)

# 第二种（无需）
def test2(name, age):
    print(f"{name}, {age}岁了")

test2(age = 20, name = "whx")

# 第三种(默认值)
# 默认值必须从最后一个参数开始
def test3(name, age = 18):
    print(f"{name}, {age}岁了")

test2(name = "whx")

# 第四种（不定长tuple）
def test3(*args):
    print(f"{args}")

test3("654", 4, 11)

# 第五种（不定长dict）
def test4(**kwargs):
    print(f"{kwargs}")

test4(whx = 20, zsy = 18)

匿名函数

函数作为参数传递 

def add(compute):
    result = compute(1, 2)
    print(f"{result}")

def compute(x, y):
    return x + y

add(compute)

lambda匿名函数

只能用一次

def add(compute):
    result = compute(1, 2)
    print(f"{result}")

add(lambda x, y : x + y)