python入门

变量

变量命名规则

变量名只能是字母，数字和下划线的任意组合
变量名第一个字符不能是数字
变量名区分大小写，大小写字母被认为是两个不同的字符
特殊关键字不能命名为变量名

变量赋值

# 单条赋值
name='张三'
# 多条赋值
a=b=c=1
x,y,z=114514,1919810,"homo"
print(a,b,c)
print(x,y,z)

数据类型

六个数据类型
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

number

Python3 支持 int、float、bool、complex

String

三种定义方式

# 双引号定义
str1 = "hello"
# 单引号定义
str2 = 'hello'
# 三引号定义(支持换行)  用变量接收它就是字符串，不接收就是注释
str3 = """hello
         world
         """

字符串的拼接

# 加号拼接法(不能直接拼数字)
str="傅桑"+"家乡的sakura开了"
print(str)

# 占位符拼接法
# 占位符
# %s 将内容转换成字符串，放入占位位置
# %d 将内容转换成整数，放入占位位置
# %f 将内容转换成浮点型，放入占位位置
str="%s读书的好地方，%s,%d,%f" % ('师专',114514,3.14145,10)
print(str)


# 对数据的精度进行控制
# %m.nf
# m代表数据的长度，当设置的值小于字符串长度时不生效
# 前面可以加的负号，不加代表不足的长度在前面补空格，符号代表在后面补空格
# n表示要保留几位小数，这里是四舍五入
print("%10.3f114514" % 10.5555)


# 用f快速的进行拼接(无法对数据的精度进行控制)
p1="jack"
p2='rose'
hooby='jump'
print(f"{p1},{hooby};{p2},{hooby}")

剩下的会在数据容器当中进行介绍

运算符

运算符	描述
+	加
-	减
*	乘
/	除
//	取整除
%	取余
**	指数

示例

print(1+1)          # 结果：2
print(2-5)          # 结果：-3
print(5*5)          # 结果：25
print(2/3)          # 结果：0.6666666666666666
print (5//2)        # 结果：2
print(10%3)         # 结果：1
print(2**5)         # 结果：32

符合赋值运算符

num=10
num+=1
num-=1
num**=2

输入输出

input()：读取键盘输入
print()：打印输出

name=input("你是谁")
print("我是：",name)

要注意无论输入的是什么，接收到的永远是字符串类型

age=input("你几岁了？")
print(type(age))

if语句

# 基本格式

# 判断条件后面有一个冒号
# 归属于if语句的代码块，需要在前面有四个的空格缩进

if 1 + 1 == 2:
    print("居然相等")
else:
    print("你不会来真的吧")

循环

while循环

import random

a = random.randint(1, 10)
b = 0
i = 1
while b != a:
    b = input("请输入你要猜的数字")
    b = int(b)
    if b > a:
        print("不对哦，猜大了")
    elif b < a:
        print("不对哦，猜小了")
    else:
        print(f"你太棒了，就用了{i}次就猜到了")
    i += 1

for循环

# for 临时变量 in 待处理数据集
# 待处理数据集，又叫序列类型
# 序列类型：其内容可以被一个一个的取出
# 常见序列类型：字符串，列表，元组等

name = 'zhangsan'
for n in name:
    print(n)

# range语句
range(5)       # 表示0-4的整数
range(5,10)    # 表示[5,10)
range(5,10,2)  # 表示(5,7,9),第三个参数表示步长

# 以此我们常常可以将range语句和for循环搭配起来使用

for i in range(10):
    print(i)

for的临时变量作用域

# 要注意,这里的定义的临时变量，虽然可以在for循环作用域的外部生效，但是按照编码规范是不允许的
for i in range(10):
    print(i)

print(i)

函数

函数是组织好的，可重复使用的，用来实现特定功能的代码块

# 函数的定义
def 函数名(参数):
    函数体
    return 返回值

函数中变量的作用域只在函数内部，但是可以通过global关键词将其变为全局变量

多返回值

# python的函数是可以有多个返回值的，用法如下
def test_fun():
    return "zjnu", 666


a, b = test_fun()
print(f'a的值为{a},b的值为{b}')

参数的传递

1.位置参数

需要位置一一对应

def param_fun(name, age, gender):
    return None

param_fun("张三", 18, '男')

2.关键词参数

通过这种形式不需要位置的意一一对应

def param_fun(name, age, gender):
    return None

param_fun(name="张三", gender='男', age=18, )

3.缺省参数

在定义函数的是可以指定参数的默认值，没写这个参数，就会使用这个默认值
同时这里要注意，默认参数只能放在所有参数的最后面

def param_fun(name,gender, age=18 ):
    return None

4.不定长参数

位置不定长
以元组的形式传递参数，一般命名为args

def param_fun(*args):
    return None


param_fun(1, 2, 1, 'name')

关键词不定长
以字典的形式传递，一般命名为kwargs

def param_fun(**kwargs):
    return None


param_fun(key1=1, key2=2, key3=1, key4='name')

匿名函数

def test_fun(add):
    result = add(1, 2)
    return print(f'输出的结果是{result}')


test_fun(lambda x, y: x + y)

数据容器

可以通过是否支持修改，是否可以有重复元素，是否有序将容器分为列表，元组，字符串，集合，字典

列表

定义

# 列表的定义
list1 = [1, 2, 3, 4, 5, 6]
# 格式化
list2 = list()
print(list1)
print(list2)

# 列表内支持存储不同数据类型的数据
list3 = ['114514', 1919810, 3.14,True]
print(list3)

通过下表获取列表中的元素

list3 = ['114514', 1919810, 3.14, True]

# 列表的下表的索引值是从0开始的
print(list3[3])  # 输出值为True

# 负数的索引为从前往后,-1为最后一个元素
print(list3[-4])  # 输出值为114514

# 嵌套列表的索引获取
list4 = [[1, 2, 3, 4], [5, 6, 7, 8, 9]]
print(list4[1][-1])  # 输出值为9

# 使用下表索引的时候，注意不要越界

列表常用的方法

list5 = [1, 2, 3, 4, 5]

# index,查找数组中是否存在该元素，如果找不到就报错ValueError,找到则返回对应元素的索引
print(list5.index(5))  # 输出结果4

# insert，接收两个参数，第一个为要插入的位置的索引，第二个为要插入的元素
list5.insert(1, 99)
print(list5)  # 输出结果[1, 99, 2, 3, 4, 5]

# append,在列表的尾部新加元素
list5.append(6)
list5.append([1, 2, 3, 4])
print(list5)  # 输出结果[1, 99, 2, 3, 4, 5, 6, [1, 2, 3, 4]]

# extend，也是在尾部追加，但是如果是追加其他容器，则会将容器中的元素拆开
list5.extend([100, 101, 102])
print(list5)  # 输出结果[1, 99, 2, 3, 4, 5, 6, [1, 2, 3, 4], 100, 101, 102]

# del关键词
del list5[0]
print(list5)  # 删除了1

# pop
num = list5.pop(0)
print(num)  # 删除了99

# remove，删除从前往后匹配到的第一个元素,同样没有该元素会报ValueError的错
list5.remove(2)
print(list5)  # 删除了2

# clear，清空列表
list5.clear()
print(list5)  # 输出结果[]

list6 = [1, 1, 1, 2, 3, 4, 5]
# count,统计某个元素的数量
print(list6.count(1))  # 输出结果为3

# len,统计列表长度
print(len(list6))  # 输出结果为7

列表的特点

上限元素有2^63-1个，9223372036854775807个
可以容纳不同的数据类型
数据是有序存储的
可以有重复的数据
可以修改

元组

定义

# 定义
# 如果只有一个元素，需要在该元素后面加一个逗号
tuple1 = (1,)
print(tuple1)

# 格式化
tuple2 = tuple()
print(tuple2)

常用方法

tuple3 = ('114514', 'str', 1919810, 1, 1, 1, (1, 2, 3))

# 索引获取
print(tuple3[-1][0])   # 输出1

# index，和list用法相似
print(tuple3.index('str'))   # 输出1

# count,和list用法相似
print(tuple3.count(1))  # 输出3

# len,和list用法相似 
print(len(tuple3))   # 输出7

元组的特点

可以容纳不同的数据类型
数据是有序存储的
可以有重复的数据
不可以修改

字符串

常用方法

str1 = 'zjnu_zjnu'

# 索引
print(str1[-5])  # 输出的值为 _

# index
print(str1.index('zjnu'))  # 输出的值为0

# replace,要注意不是修改，而是返回一个新的字符串
str2 = str1.replace('zjnu', 'zju')
print(str2)  # 输出的值为zju_zju

# split,按照指定的字符串进行分割，并将结果储存在列表中
list1 = str1.split('_')
print(list1)  # 输出的值为['zjnu', 'zjnu']

# strip
# 去除前后的空格
str3='     hello world    '
print(str3.strip())   # 输出的值为hello world
# 去除前后的指定的字符串，里面的按照单个字符进行匹配
str4='12hello world21'
print(str4.strip('12'))    # 输出的值为hello world

# count
print(str1.count('zjnu'))   # 输出的值为2

# len
print(len(str1))  # 输出的值为9

字符串的特点

只可以存储字符串
数据是有序存储的
可以有重复的数据
不可以修改

对序列切片操作

我们将列表，元组，字符串这种可以通过索引获取元素的容器，叫做序列

# 切片操作
# 序列[a:b:c]
# a代表要取的起点
# b代表要取的终点(不包含)
# 当起点和终点为序列的头和尾是可以省略
# c代表步长，步长为1是可以省略，也可以负数
str5 = '0123456789'
result = str5[::-1]   # 9876543210
print(result)

集合

# 定义
set1={1,1,1,2}
print(set1)

# 格式化
set2=set()
print(set2)

集合的常用方法

# 定义
set1 = {1, 1, 1, 2, 3, 4}
print(set1)  # 输出结果是{1, 2, 3, 4}

# 格式化
set2 = set()
print(set2)  # 输出结果是set()

# add，添加新元素
set1.add('zhangsan')
print(set1)  # 输出结果是{1, 2, 3, 4, 'zhangsan'}

# remove,移除元素
set1.remove('zhangsan')
print(set1)  # 输出结果是{1, 2, 3, 4}

# pop，随机取出一个元素
print(set1.pop())  # 输出结果是?

# clear,清空集合
set1.clear()
print(set1)  # 输出结果是set()

# difference
set3 = {1, 2, 3, 4}
set4 = {1, 3, 5, 7}
diff_set=set3.difference(set4)
print(diff_set)  # 输出结果是{2, 4}

# difference_update,在调用方法的集合中删除相同的元素
set3.difference_update(set4)
print(set3)    # 输出结果是{2, 4}

# union,两个集合取并集
union_set=set3.union(set4)
print(union_set)   # 输出结果是{1, 2, 3, 4, 5, 7}

# len
print(len(union_set))  # 输出结果是6

集合的特点

可以存储多种数据
数据是无序存储的
不可以有重复的数据
可以修改

字典

定义

# 定义
dict1={"张三":18, "李四":17, "王五":19}
print(dict1)  # 输出的结果是{'张三': 18, '李四': 17, '王五': 19}

# 定义一个空字典
dict2=dict()
print(dict2)  # 输出的结果是{}

要注意key的值是不可重复的，如果重复的话，后写入的会将之前写入的给覆盖

常用操作

# 定义
dict1 = {"张三": 18, "李四": 17, "王五": 19}
print(dict1)  # 输出的结果是{'张三': 18, '李四': 17, '王五': 19}

# 定义一个空字典
dict2 = dict()
print(dict2)  # 输出的结果是{}

# 增加
dict1['赵六'] = 20
print(dict1)  # 输出的结果是{'张三': 18, '李四': 17, '王五': 19, '赵六': 20}

# 修改
dict1['张三'] = 100
print(dict1)    # 输出的结果是{'张三': 100, '李四': 17, '王五': 19, '赵六': 20}

# 删除
dict1.pop('赵六')
print(dict1)   # 输出的结果是{'张三': 100, '李四': 17, '王五': 19}

# 获取全部的key
keys=dict1.keys()
print(keys)   # 输出的结果是dict_keys(['张三', '李四', '王五'])

# 清空
dict1.clear()
print(dict1)  # 输出的结果是{}

字典的特点

每一份数据都是一个键值对
不可以有重复的key
可以存储多种数据
数据是无序存储的
可以修改

文件的读取和写入

打开文件

# name文件名
# mode，打开的模式
# mode，文件编码的格式
f=open(name,mode,encoding)

mode的三种访问模式

模式	描述
r	只读
w	文件已存在覆盖写入，不存在，创建并写入
a	文件已存在，在已有内容后面写入，不存在，创建并写入

文件的读取

# read中的参数，表示读取几个字符
# 不填写参数默认读取全部
print(f'read方法读取的是"{f.read(10)}"')


# readlines一次性读取全部的内容
print(f.readlines())


# readline读取一行的数据
for line in f:
    print(line)

需要注意当操作完文件后，要调用close方法，取关闭对文件的占用。

f.close()

或则一下的方法获取文件对象

with open('test.txt', 'r', encoding="UTF-8") as f:
    for line in f:
        print(line)

这样会自动的在文件操作完毕后，结束对文件的占用

文件的写入

注意当我们调用write方法是，内容并没有写入文件，而是在缓冲区内，而只用当我么调用flush方法是，才会将内容写入磁盘。这样可以减少IO操作，提高效率。

f = open('test2.txt', 'w', encoding="UTF-8")
f.write('hello world')
# close方法内置了flush，因此调用了close，就不需要再调用flush
f.close()

当然我们将模式改成a，就可以实现对文件的追加写入了

异常

异常捕获

try:
    a = 10 / 0
    print(a)
except:
    print('出现除数为0的异常')


# 捕获指定的异常
try:
    print(name)
except NameError as e:
    print(e)

# 捕获多个异常
try:
    print(1/0)
except (NameError,ZeroDivisionError) as e:
    print(e)


# else语句，没有异常执行
# finally，运行结束
try:
    print(1/10)
except (NameError,ZeroDivisionError) as e:
    print(e)
else:
    print('无事发生')
finally:
    print('运行结束')

面向对象

类的定义

class Student:
    # 用两个下划线开头的成员变量为私有成员变量
    __password = None

    # 构造方法
    def __init__(self, name, age, gender, password):
        # 成员变量
        self.name = name
        self.age = age
        self.gender = gender
        self.__password = password

    # 成员方法
    def show(self):
        print(f'学生的名字是{self.name},学生的年龄是{self.age},学生的性别是{self.gender}')

    # 类似于java的tostring方法
    def __str__(self):
        return f"学生的名字是{self.name},学生的年龄是{self.age},学生的性别是{self.gender},学生的密码是{self.__password}"

    # 用于定义两个对象大于小于关系的比较
    def __lt__(self, other):
        return self.age < other.age

    # 用于定义两个对象之间的大于等于和小于等于关系
    def __le__(self, other):
        return self.age <= other.age

    # 用于定义两个对象之间是否相等的方法，不写这个方法默认比较两个的内存地址
    def __eq__(self, other):
        return self.name and other.name and self.age == other.age and self.gender == other.gender

    # 私有方法
    def __test(self):
        return '这是一个私用方法'

创建对象

student = Student('张三', 18, "男", "123456")

继承

python是支持多继承的
如果多个父类中有相同的方法或成员变量，按照从左往右的优先级进行覆盖

class Wheel:
    def function(self):
        print('我会滚')


class Car:
    weight: None
    height: None

    def __init__(self, weight, height):
        self.weight = weight
        self.height = height

    def function(self):
        print('我开的很快')

    def __str__(self):
        return f'车的重量是{self.weight},车的高度是{self.height}'


class Audi(Car, Wheel):
    # 用于跳过格式，不用在类中写方法
    # pass
    def __init__(self, weight, height):
        Car.__init__(self, weight, height)


audi = Audi(180, 180)
audi.function()
print(audi,audi.height)

多态以及抽象类

抽象方法就是方法体中不写任何的内容，写一个pass关键词，跳过python的格式检查

class Payment:
    def pay(self):
        pass


class AliPay(Payment):
    def pay(self):
        print('支付宝支付')


class WeChat(Payment):
    def pay(self):
        print('微信支付')


def payMoney(pament: Payment):
    pament.pay()


ali = AliPay()
wechat = WeChat()

payMoney(ali)
payMoney(wechat)

类型注解

这一点可以和java当中的泛型相类比
我们可以在变量，对象或容器定义的时候指定其类型，但是要注意，这个只是一个提示，并不会强制要求这个只能是指定的类型

a: int = 'a'

student: Student = Student('张三', 18, "男", "123456")

test_list: list[int] = [1, 2, 3, 4]

test_dict: dict[str, int] = {'age': 18}

def add(x:int,y:int) ->int:
    return x+y