Python基础入门

输入输出

1
2
3
4
a = "hh"
a = 1.1
a = 2
print(a)

格式化

1
2
3
4
a = 1.1
print("%s" % a)   1.1
print("%.2f" % a)  1.1
print("%f" % a)    1.100000

快速格式化

语法：

  • f " 内容 { 变量 } " 的格式来快速格式化
  • 示例：
1
2
3
4
name = "张三"  
price = 11.12  
year = 34  
print(f"我是{name},今年{year},这个价格是{price}")
1
2
3
4
5
6
print("请输入")
name = input()

与
name = input("请输入")
等效

注意：

  • input 语句输入默认为字符串类型
  • 要用其他类型需要强制转换
  • int() 、str()、float()

语法

布尔类型 True、False

赋值

** 为幂运算 2 ** 3.1 = 8.574187700290345

1
a, b = 12, 13  #这是合法的

if

1
2
3
4
5
6
7
8
9
age = 12  
year = 12  
if age >= 18:  
    print("成年了")    # 四个空格缩进
    print("哈哈")  
elif year == 12:  
    print("OHOHOH")  
else:  
    print("NO")

循环

1
2
3
4
5
6
7
i = 1;  
while i < 3:  
    print(i)  
    i += 1
    j = 1
    while j < 10:
        print("hh")
1
2
3
name = "zhangsan"  
for x in name:  
    print(x)         将name中的内容挨个取出，然后打印

数据容器

list(容器)：将给定容器转换为列表 str(容器)：将给定容器转换为字符串 tuple(容器)：将给定容器转换为元组 set(容器)：将给定容器转换为集合

字符串转为其他是一个一个字符取出，字典转为其他是将 key 取出

sorted(容器，reverse=true)：使用这个函数，会自动将其转换为列表，第二个参数不写，默认为升序，写 false 为降序

集合—set

内部和 C++的 set 容器一样，会进行升序排列

集合的定义：{3，2，1} 空集合的定义：temp = set()

操作 说明
集合. add (元素) 集合内添加一个元素
集合. remove (元素) 移除集合内指定的元素
集合. pop () 从集合中随机弹出一个数
集合. clear () 清空集合
集合 1. difference (集合 2) 得到一个新集合，内含 2 个集合的差集（集合 1 中不包含集合 2 的元素集合），原有的 2 个集合内容不变
集合 1. difference_update (集合 2) 在集合 1 中，删除集合 2 中存在的元素，集合 1 被修改，集合 2 不变
集合. union (集合 2) 得到一个新集合，内含 2 个集合的全部元素。原有的 2 个集合内容不变
len (集合) 得到一个整数，记录了集合的元素数量
max (集合)，min (集合) 获得集合里的最大值最小值

字典—dict

会自动去重，按照键去重，直接定义的，相同键，后面的 value 会替换到在之前的 格式：{键：值，键：值}

例子

1
2
temp = {11:10, 11:20}
# 最终保留的是 11:20

定义字典：{"张三": 14, "李四": 15} 空字典：temp = dict ()

获取值：temp[键key] 即可

操作 说明
字典[key] 获取指定 key 对应的 value 值
字典[key] = value 添加或更新键值对
字典. pop (key) 取出 key 对应的 value 并在字典内删除此 key 的键值对
字典. clear () 清除字典
字典. keys () 获取字典的全部 key，可用于 for 循环遍历字典
len (字典) 计算字典内的元素数量
max (字典)，min (字典) 获取字典中 key 的最大值最小值

列表、元组

切片

  • 起始下标表示从何处开始，留空视作从头开始
  • 结束下标表示结束，留空视作截取到结尾，含的下标，截取不会包含当前下标
  • 步长表示取的间隔
    • n 表示每次跳过 n-1 个元素取
    • 负数表示反向

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
"""  
"万过月薪, 员序程马黑来, nohtyp学"  
"""  
my_str = "万过薪月,员序程马黑来,nohtyp学"  
  
# 倒序字符串，切片取出  
result1 = my_str[::-1][9:14]  
print(result1)  
  
# 切片取出，然后倒序  
result2 = my_str[5:10][::-1]  
print(result2)  
  
# split分隔", " replace替换"来"为空，倒叙字符串  
result3 = my_str.split(",")[1].replace("来", "")[::-1]  
print(result3)
函数 功能
列表. append (元素) 向列表中追加一个元索
列表. extend (容器) 将数据容器的内容依次取出，追加到列表尾部
列表. insert (下标，元素) 在指定下标处，插入指定的元素
del 列表[下标] 删除列表指定下标元素
列表. pop (下标) 删除列表指定下标元素
列表. remove (元素) 从前向后，删除此元素第一个匹配项
列表. clear () 清空列表
列表. count (元素) 统计此元素在列表中出现的次数
列表. index (元素) 查找指定元素在列表的下标，找不到报错 ValueError
len (列表) 统计容器内有多少元素

函数

多返回值

1
2
3
4
def func():
    return 10, 20
    
x, y = func()

函数传参

位置参数

1
2
3
4
def func(x, name):  
    print(f"{x}, {name}")  
  
func(10,"z")

关键字参数

1
2
3
4
def func(x, name):  
    print(f"{x}, {name}")  
  
func(x = 10, name = "z")

缺省参数

不传参数，就使用默认的，传了参数，使用传的

1
2
3
4
def func(x, name = "zhangsan"):  
    print(f"{x}, {name}")  
  
func(x = 10)

不定长与定长参数

不定长：一个 * 号，原理是一个元组，args 是元组

1
2
3
4
def func(*args):  
    print(args)  
  
func(1,2,3,4)

不定长：两个 * 号，原理是一个字典

1
2
3
4
def func(**args):  
    print(args)  
  
func(name='zhangsan',age=12 ,gender='男')

函数作为参数传参

1
2
3
4
5
6
7
def func(add):  
    add('zhang', 20)  
  
def add(name, age): 
    print(f"{name}, {age}")  
  
func(add)

匿名函数

语法：lambda 传入参数: 函数体（一行代码）

1
2
3
4
def func(add):  
    add('zhang', 20)  
  
func(lambda name, age: print(f"{name}, {age}"))

异常

1
2
3
4
5
6
7
8
9
10
11
12
try:
    可能要发生异常的语句
except:
    出现异常后的执行语句
else:
    未出现异常时可以做的事情
finally:
    无论是否出现异常，都要执行，一般用于关闭文件
    
# 未出现异常时：执行 try, else, finally 语句
# 出现异常时：执行 except, finally 语句
# 顶级父类 Exception
1
2
3
4
5
6
# 可以捕获多个异常，只要出现异常，后面不在执行，也就是这里只捕获到 name 异常
try:  
    print(f"{name}, {1/0}")  
except (ZeroDivisionError, NameError) as e:  
    print("出现异常了")  
    print(e)

异常的传递性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def func1():  
    num = 1/0  
    print(name)  
  
def func2():  
    func1()  
  
def main():  
    try:  
        func2()  
    except ZeroDivisionError:  
        print("有异常")  
  
main()

可视化图表

json 格式

  • 列表（但是内部仍然是字典）
  • 字典
1
2
3
4
5
6
7
8
9
10
11
import json  
data = [{"老王": 1, "age": 16}, {"张三":2, "age": 20}]  
  
# 转换为 json 格式  
j_str = json.dumps(data, ensure_ascii=False)  
print(j_str)  
print(type(j_str))  # 实际是个字符串
  
# 转换为列表  
data1 = json.loads(j_str)  
print(data1)

pyecharts 基础使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from pyecharts.charts import Line  
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts  
  
# 创建一个折线图对象  
line = Line()  
  
# x 轴添加数据  
line.add_xaxis(["中国", "美国", "英国"])  
# y 轴添加数据  
line.add_yaxis("GDP", [30, 20, 10])  
  
# 设置全局配置项  
line.set_global_opts(  
    # 标题  
    title_opts=TitleOpts(title="GDP展示", pos_left="center", pos_bottom="1%"),  
    # 图例，默认也是 True    legend_opts=LegendOpts(is_show=True),  
    toolbox_opts=ToolboxOpts(is_show=True),  
    visualmap_opts=VisualMapOpts(is_show=True),  
)  
  
# 通过 render 方法，将代码生成图像  
line.render()

类和对象

类里面的魔术方法

类似于运算符重载

方法 功能
__int__ 构造方法，初始化
__str__ 实现直接输出对象
__lt__ 实现对象的小于大于比较
__le__ 实现对象的小于等于和大于等于比较
__eq__ 实现对象是否等比较
示例 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Student:  
    name = None  
    age = None  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def __str__(self):  
        return f'{self.name} {self.age}'  
    def __le__(self, other):  
        return self.age < other.age  
  
student1 = Student('John', 23)  
student2 = Student('Jack', 25)  
print(student1)  
print(student1 <= student2)

# 输出
# John 23
# True

封装、继承、多态

私有成员和方法

加 “__“ 两个下划线

继承

1
2
3
4
5
6
7
8
9
# 单继承
class Student(父类名)
# 多继承
class Student(父类1，父类2)

# pass 用法，补全语法
class Student(父类1，父类2)
    pass
# 这样防止语法报错，因为感觉功能多了，不需要实现体了