Python从入门到入坑（黑马课程）

运算符	描述	示例
+	加	4 + 2 = 6
-	减	4 – 2 = 2
*	乘	4 * 2 = 8
/	除	4 /2 = 2
//	取整数，返回除法的整数部分	4 // 2 = 2; 9 // 2 = 4
%	取余数	4 % 2 = 0；5 % 2 = 1
**	幂，平方、次方	1 2 = 2；4 0.5 = 2

比较运算符

运算符	描述	示例
==	检查两个操作的值是否相等，如果是，则条件成立，返回True	1 == 1 “haha” == “haha”
!=	检查两个操作的值是否不相等，如果是，则条件成立，返回True	2 != 1 “haha” != “heihei”
>	检查左边的数值是否大于右边的数值，如果是，则条件成立，返回True	2 > 1
<	检查左边的数值是否小于右边的数值，如果是，则条件成立，返回True	1 < 2
>=	检查左边的数值是否大于等于右边的数值，如果是，则条件成立，返回True	1 >= 1
<=	检查左边的数值是否小于等于右边的数值，如果是，则条件成立，返回True	1 <= 1

逻辑运算符

运算符	描述	示例
and	逻辑与运算，等价于数学中的“且”	a and b（成立条件：a与b都为真）
or	逻辑或运算，等价于数学中的“或”	a or b（成立条件：a或者b只有一个满足条件）
not	逻辑非运算，等价于数学中的“非”	not a（成立条件：对a取反）

运算符	描述	示例
=	最基本的赋值运算	1 = 1
+=	加赋值	x += 1等同于x = x + 1
-=	减赋值	x -= 1等同于x = x - 1
*=	乘赋值	x -= 1等同于x = x - 1
/=	除赋值	x /= 2等同于x = x / 2
%=	取余数赋值	x %= 2等同于x = x % 2
**=	幂赋值	x = 2等同于x = x 2
//=	取整数赋值	x //= 2等同于x = x // 2
&=	按位与赋值	x &= y等同于 x = x & y
\|=	按位或赋值	x \|= y等同于 x = x \| y
^=	按位异或赋值	x ^= y等同于 x = x ^ y
<<=	左移赋值	x <<= 1等同于x = x << 1
>>=	右移赋值	x >>= 1等同于x = x >> 1

转义字符

运算符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\”	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页

变量使用

变量定义

变量名 = 值

phone = '010-8869'
print(phone)

变量类型

# 1.    数字类型：
a = 1
print(a, "是", type(a), "类型")

# 2.   字符串类型
a = "哈哈"
print(a, "是", type(a), "类型")

# 3.   列表类型
a = ["大", "王"]
print(a, "是", type(a), "类型")

# 4.   元组类型
a = (1, 2)
print(a, "是", type(a), "类型")

# 5.   集合类型
a = {'red', 'green'}
print(a, "是", type(a), "类型")

# 6.   字典类型
a = {'name': '王', 'age': '18'}
print(a, "是", type(a), "类型")


# 7.   布尔类型
a = True
b = False
print(a, "是", type(a), "类型")
print(b, "是", type(b), "类型")

变量命名

Python中，变量名由字母、数字和下划线组成，且不能以数字开头。变量名大小写敏感，因此"myVariable"和"myvariable"是不同的变量名。为了提高代码的可读性，建议使用有意义的变量名。例如，可以用"age"代表一个人的年龄，用"name"代表一个人的姓名。此外，还可以使用驼峰命名法，将多个单词连接在一起，每个单词的首字母都大写，例如"myAge"和"myName"。

变量名不应过长，通常应该尽量简短且具有描述性
Python有一些保留字，这些保留字被编程语言预先定义，不能用作变量名
根据PEP 8，变量名应该用小写字母，并且可以使用下划线来分隔单词

变量函数

input函数

用户输入的任何内容默认都为字符串类型，可以参考如下将Str转换成int

num = int(input('输入数字：'))
print(num)
print(type(num))

num = input('香蕉的单价：')
num2 = input('买几斤？买；')

price = float(num) * float(num2)
print(price, '元')

type函数

查看该变量的类型，使用type()

num = float(input('输入数字：'))
print(num)
print(type(num))

条件语句

If

格式

if 要判断的条件1:

        条件1成立时，要做的事情

        ......

elif 要判断的条件2:

        条件2成立时，要做的事情

        ......

else:

        条件不成立时，要做的事情

案例1，判断年龄

输入年龄，如果年龄小于18，不让入内，如果大于等于18可以入内


if age < 18:
    print("未成年人禁止入内")
elif age >= 18:
    print("正常票价")

案例2，借钱

发工资了：借钱超过100以上没钱，100以下可以借，没发工资直接退出

import sys

info = input("你发工资了吗？")
if info == 'no':
    print("没发")
    print("好的，那算了吧，本来还想问你借点钱的")
    sys.exit()
if info == 'yes':
    number = int(input("借我点钱:"))
    if number >= 100:
        print("我没那么多钱")
    else:
        print("可以")

案例3，and、or应用

a = 1
b = 2
if a > 0 and b > 1:   #a和b都满足条件时，成立
    print("条件表达式1成立")
if a > 4 or b > 3:    #a或者b都满足条件时，成立，反之不成立
    print("条件表达式2成立")
else:
    print("未满足其中一项，条件表达式2不成立")
if not a < 0:        #a结果取反，满足条件时，条件成立
    print("条件表达式3成立")

循环语句

for

格式

for 变量 in 可迭代对象:

        执行语句1

        ......

else:

        执行语句2

        ......

案例1，打印一个列表

list_info = ['哈哈', '呵呵', '嘿嘿']
for i in list_info:
    print(i, end=' ')

打印一个列表，不自动换行，结尾以空格显示

案例2，判断数字是偶数还是奇数

for i in range(1, 11):
    if i % 2 == 0:
        print(f"数字{i}是偶数")
    else:
        print(f"数字{i}是奇数")

打印数字1~~10，判断数字是否除以2的余数为0

案例3，查找列表中的最大值和最小值

list_info = [1, 2, 4, 10, 55, 100, 86]
max_info = list_info[0]
min_info = list_info[0]

for i in list_info:
    if i > max_info:
        max_info = i
    if i < min_info:
        min_info = i
print(f"最大值是{max_info}")
print(f"最小值是{min_info}")

使用for循环依次去取列表的第一个值，第一次是1，第二次2......，这样每次找到的最小的或者是最大的数都会将当前变量更新为最大或最小数

While

格式

while 判断语句:

执行的代码

......

案例1，打印5遍字符串

用while循环打印5遍hello word

定义一个初始数值，记录循环次数。当循环次数的判断条件满足时，程序退出

count = 5
while count > 0:
    print("hello word")
    count = count - 1
    if count == 0:
        print("打印5遍完成,跳出循环")
        break
print("game over")

定义一个初始数值，记录循环次数。当循环次数的判断条件不满足时，程序退出

count = 0
while count < 5:
    print("hello word")
    count = count + 1
print("已打印了5遍")

案例2，计算1到10的求和

i = 0
result = 0
while i <= 100:
    result += i
    i += 1
print(result)

案例3，计算1到10的偶数求和

i = 0
result = 0
while i <= 100:
    i += 1
    #判断i中的值除以2是否等于0，验证其是否是偶数
    if i % 2 == 0:
        result += i
    # print(result)

print(result)

案例4，验证用户密码

count = 3
while count > 0:
    name = input("登陆用户名：")
    pwd = int(input("密码："))
    if name == "admin" and pwd == 123 or name == "wyq" and pwd == 123:
        print("用户名密码正确，正在登陆...")
        print("登陆成功")
        break
    else:
        count = count - 1
        if count > 0:
            print(f"用户名或者密码错误，请重新尝试,您还有{count}次机会")
        else:
            print("次数用尽,登陆失败，程序退出！")

当用户名密码均正确时，直接退出程序

当用户密码错误的时候，每次验证次数递减1，当剩余次数为0时，提示退出

Break

break:跳出整个循环，不会再循环该循环内容

i = 0
while i < 5:
    i = i + 1
    if i == 3:
        break
    print(f"当前i的值是{i}")
print(f"当退出循环时，i的值是{i}")

当i等于3时，跳出终止整个循环，所以当前循环内i的值应该是1和2，因为当i等于3的时候，break终止整个循环了

Contiune

continue:跳出本次循环，continue后面的代码不再执行，但是循环依然继续

a = 0
while a < 3:
    a = a + 1
    if a == 2:
        continue
    print(f"跳出本次循环后a的值是{a}")
print(f"当前a的值是{a}")

当a等于2时，跳出本次循环，后面的代码不执行，但是循环体依然进行，所以当前a的值是1和3。因为当a等于2的时候，contiune不执行后面的代码语句

while循环嵌套

九九乘法表

#定义一个行的循环，输出9行
row = 1
while row <= 9:

    #定义一个列的循环
    col = 1
    #当列小于行时
    while col <= row:
        result = row * col
        print(f"{col} * {row} = {result}\t", end=" ")
        #print(row)
        col = col + 1
    print()
    row = row + 1

函数

函数的基本使用格式

函数的作用

所谓函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候的调用

函数使用包含两个步骤：

定义函数--封装独立的功能

调用函数--享受封装的成果

函数的命名规则

可以由字母、下划线和数字组成
不能以数字开头
不能与关键字重名

函数的格式

def 函数():

执行语句1

......

函数()

def print_hello():
    print("hello word")


print_hello()

函数的参数

在函数名的后面的小括号内部填写参数，多个参数用，分割

def get_sum(age1, age2):
    result = age1 + age2
    print(result)


get_sum(18, 20)

形参

定义函数时，小括号中的参数是用来接收参数用的，在函数内部作为变量使用

实参

调用函数时，小括号的参数，是用来把数据传递给函数内部用的

函数的返回值return

在开发程序中，有时候希望一个函数执行结束后，攻速调用者一个结果，便于针对这个结果做后续的处理

在函数中可以使用return关键字来返回结果

调用函数一方，可以使用变量来接收函数的返回结果

注意：return表示返回，后续的代码都不会被执行

定义一个函数get_sum，定义形参age1和age2，使用return返回两个形参的总和，在调用函数时先定义实参get_sum(18, 20)后，通过变量赋值来获取结果
def get_sum(age1, age2):
    result = age1 + age2
    return result


a = get_sum(18, 20)
print(a)

观察下面示例，为什么 print("hahahaha") 没有执行？
def number(age):
    if age < 18:
        print("年龄小于18")
        return "未成年人禁止入内"
        print("hahahaha")
    else:
        return "已成年"


print(number(15))
因为return后的语句不执行，所以没有执行 print("hahahaha")

观察下面示例，为什么有的时候打印的值返回了None？

def get_list():
    list_info = ['admin', 'root', 'ubuntu']
    for i in list_info:
        print(i)


print(get_list())


def get_list():
    list_info = ['admin', 'root', 'ubuntu']
    for i in list_info:
        print(i)
    return "列表打印完成"


print(get_list())

因为当return默认为空时，返回的就是None

利用元组返回多个值

如果需要在函数内返回多个变量的值，可以使用return 变量1，变量2 返回一个元组列表
def test3():
    name = "wang"
    age = 18
    # TODO ，函数需要返回多个变量的情况下。等同于return (name, age)，返回的是元组
    return name, age


# TODO 相当于使用多个变量接收元组的结果，其变量个数与元组个数应保持一致
gl_name, gl_age = test3()
print(gl_name, gl_age)
使用return name，age返回了一个元组，然后使用多个变量接收元组的结果

函数返回值交换两个变量的值

相当于定义了多个变量a和b接收元组的值，将b赋值给a，a赋值给b
a = 6
b = 100


a, b = b, a
print(f"a的值是{a}")
print(f"b的值是{b}")

函数的缺省参数

定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫 缺省参数
def print_info(name, gender=True):
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print(f"{name}是{gender_text}")


print_info("小明", True)
print_info("小美", False)
上述代码定义了一个缺省参数 gender，gender默认为True，所以输出的是男生，当gender不是默认的True而是False的时候，则取反了

函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是函数嵌套

观察下面的示例

执行函数test2中，调用了另外一个函数test1，那么如何工作？

def test1():
    x = 5 * 2
    print(f"这是test1函数打印的x值：{x}")
    return x


def test2():
    y = 10 / 5
    print(f"y的值是{y}")
    z = test1() + y

    print(f"这是test2函数打印的x + y = {z}")


test2()
在执行test2函数的时候先打印了y的值
接着往下碰到了test1函数，会先执行test1函数的所有任务，打印了x的值，这时test1函数任务执行完毕
然后接着回来从调用test1函数的位置后继续执行代码，打印x + y的值

在模块中定义函数

一个模块其实就是一个包含 Python 代码的文件，它可以包含变量、函数、类等。其他的 Python 程序可以通过导入模块来使用其中定义的函数和其他内容。

观察下面的示例

test.py
def person(name, age, city):
    print(f"My name is {name}, {age} years old, I'm from {city}")
函数.py
import test

test.person('wang', '20', 'ShangHai')
定义一个自我介绍信息的函数的文件“test.py”，这时没有传递形参也没有获取结果
新建一个脚本“函数.py”使用import方法将定义好函数的文件“test”导入
使用函数方法传递实参获取结果，运行”函数.py“文件即可获取到"test.py"的代码结果

例如爬虫常见的requests库，使用import requests导入库之后使用requests.get(url)来获取内容，对于自身来说，requests库就是一个包含爬取目标url信息的代码文件，我们使用其定义好的get方法来获取内容

高级数据类型

列表

List列表[]
是python中使用最频繁的数据类型，在其他语言中通常叫做数组，列表的作用是： 
  1.专门用于存储一串信息
  2.列表用[]定义，数据之间使用，分割
  3.列表的索引就是指在列表中的位置编号，从0开始，以此类推

长度就是从1开始计算

索引从左往右从0开始计算

索引从右往左从-1开始计算

列表格式

list = []

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

list = ['a', 'b', 'c']

列表操作

定义一个空列表，输入name_list. 就可以看到pycharm提示的关于列表的各种方法，下述各种方法描述：

分类	序号	关键字/函数/方法	描述
增加	1	列表.insert(索引，数据)	在指定索引位置插入数据
	2	列表.append(数据)	在末尾追加数据
	3	列表.extend(列表2)	将另一个列表的数据追加到当前列表
修改	4	列表[索引] = '数据'	修改指定索引的数据
删除	5	del 列表[索引]	删除指定索引的数据
	6	列表.remove[数据]	删除一个指定数据
	7	列表.pop	删除末尾数据
	8	列表.pop(索引)	删除指定索引数据
	9	列表.clear	清空列表
统计	10	len(列表)	获取列表长度
统计	11	列表.count(数据)	数据在列表中出现的次数
排序	12	列表.sort()	升序排序
	13	列表.sort(reverse=True)	降序排序
	14	列表.reverse()	逆序、反转，可以理解为1,2,6,4变为4,6,2,1
查询	15	列表.index()	获取某个数据的索引
查询	16	列表[ ]	查看某个索引的数据

列表操作示例

列表的增删改查基础操作

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/11/29 08:50
# @Author  : wyq
# @File    : 列表.py


OperatingSystem_list = ['Centos', 'Redhat', 'Uos', 'Kylin']
print("---", "当前的列表模板是", OperatingSystem_list, "---")
# 1. 在指定索引位置插入数据
OperatingSystem_list.insert(0, 'Winserver')
print("1. 在索引为0的地方即数据最前方插入数据'Winserver'")
print("    ", OperatingSystem_list)

# 2. 在末尾追加数据
OperatingSystem_list.append('Ubuntu')
print("2. 在末尾追加数据 'Ubuntu'")
print("    ", OperatingSystem_list)

# 3. 将另一个列表的的数据追加到当前列表
version_list = ['2012R2', '7.9', '6.5', '1020a', 'V10', '2204']
OperatingSystem_list.extend(version_list)
print("3. 将version_list列表内的数据追加到当前表")
print("    ", OperatingSystem_list)

# 4. 修改指定索引的数据
OperatingSystem_list[0] = 'Windows'
print("4. 修改索引为0的数据，即第一个数据为'Windows'")
print("    ", OperatingSystem_list)

# 5. 删除指定索引的数据
del OperatingSystem_list[0]
print("5. 删除索引为0，即第一个数据")
print("    ", OperatingSystem_list)

# 6. 删除一个指定数据
OperatingSystem_list.remove('Redhat')
print("6. 删除数据'Redhat'")
print("    ", OperatingSystem_list)

# 7. 删除末尾数据
OperatingSystem_list.pop()
print("7. 删除最末尾的数据'2204'")
print("    ", OperatingSystem_list)

# 8. 删除指定索引数据
OperatingSystem_list.pop(0)
print("8. 删除索引为0的数据，即第一个数据")
print("    ", OperatingSystem_list)

# 9. 清空列表
version_list.clear()
print("9. 清空列表version_list")
print("    ", version_list)

# 10. 获取列表长度
lens = len(OperatingSystem_list)
print("10. 获取列表OperatingSystem_list的长度")
print("    ", lens)

# 11. 数据在列表中出现的次数
counts = OperatingSystem_list.count('Uos')
print("11. 数据'Uos'在列表中出现的次数")
print("    ", counts)

# 12. 列表升序排序
OperatingSystem_list.sort()
print("12 . 将列表OperatingSystem_list升序排序")
print("    ", OperatingSystem_list)

# 13. 列表降序排序
OperatingSystem_list.sort(reverse=True)
print("13. 将列表OperatingSystem_list降序排序")
print("    ", OperatingSystem_list)

# 14. 逆序、反转：原有的表直接反转，可以理解为1,2,6,4变为4,6,2,1
OperatingSystem_list.reverse()
print("14. 将列表OperatingSystem_list逆序反转")
print("    ", OperatingSystem_list)

# 15. 获取某个数据的索引
index_data = OperatingSystem_list.index('Kylin')
print("15. 获取列表OperatingSystem_list的'Kylin'索引值")
print("    ", index_data)

# 16. 查看某个索引的数据
print("16. 获取列表OperatingSystem_list的第5个索引值的内容是")
print("    ", OperatingSystem_list[4])

列表的for循环

OperatingSystem_list = ['Centos', 'Redhat', 'Uos', 'Kylin']
version_list = ['2012R2', '7.9', '6.5', '1020a', 'V10', '2204']

OperatingSystem_list.insert(0, 'Winserver')
OperatingSystem_list.append('Ubuntu')

system_information = {}
for i in range(len(OperatingSystem_list)):
    if i < len(version_list):
        system_information[OperatingSystem_list[i]] = version_list[i]
    else:
        system_information[OperatingSystem_list[i]] = None

print(system_information)

定义了 OperatingSystem_list 列表和 version_list 列表，并对 OperatingSystem_list 进行了插入和追加操作，使用range函数获取到 OperatingSystem_list 列表的索引范围，如果索引范围小于version_list 列表的长度，分别将key和value加入到字典。如果超限了，则将key值设置为None

元組

Tuple元組（）
  1.专门用于存储一串信息，用（）定义，数据之间使用，分割。元组不能修改
  2.元組的索引和列表中的索引一樣，从0开始，以此类推

元组格式

tuple = ()

tuple = ("a", 1, 1.7)

元组操作

定义一个空元组，输入info_tuple. 就可以看到pycharm提示的关于元组的各种方法，只有count和index。因为元组不能修改，只可以查看和统计

定义一个元组，查看其类型及各个索引位置的值

info_tuple = ("zhangsan", "18", "Beijing")
print(type(info_tuple))
print(info_tuple)

print(info_tuple[0])
print(info_tuple[1])
print(info_tuple[2])

元组操作示例

元组转换成字典

list(元组)

tuple(列表)

元组本身不支持修改等操作，其本质是创建一组不可改变的数据时，将这些数据放进元组中。此示例将元组转换成列表，添加元素后在转换成元组
info_tuple = ("zhangsan", 18, "Beijing")


#使用list函数将元组先转换成列表
info_list = list(info_tuple)

#添加一个元素
info_list.append("football")
print(info_list)

#使用tuple函数将列表再转回成元组
info_tuple = tuple(info_list)

print(info_tuple)
print(f"My name is {info_tuple[0]}, {info_tuple[1]} years old, I'm from {info_tuple[2]}, "
      f"like {info_tuple[3]}")

元组循环遍历

在Python中，可以使用for循环遍历所有非数字类型的变量：列表、元组、字典、字符串，在实际开发过程中，除非能确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多
info_tuple = ("zhangsan", 18, "Beijing")
for i in info_tuple:
    print(f"{i} 类型是{type(i)}")

字典

dictionary（字典）是除列表以外python中最灵活的数据类型，字典同样可以用来存储多个数据，通常用于存储描述一个物体的相关信息

和列表的区别

列表是有序的对象集合
字典是无序的对象集合

字典用｛｝定义，使用键值对存储数据，键值对之前使用，分割

键值 key 是索引
值 value 是数据
键和值之间使用：分割
键必须是唯一的
值可以取任何数据类型，但键只能使用字符串、数字或元组

字典格式

dic = {"key1": "value1",

"key2": "value2",

......

}

字典操作

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/12/5 14:05
# @Author  : wyq
# @File    : 字典.py

person = {"name": "小明",
          "age": 18,
          "city": "北京"
          }
print("打印字典：")
print("    ", person)

#查找字典的”name“值
print("查找字典 name 的值：")
print("    ", person["name"])


# 查看字典所有键的视图
print("查看字典所有键的视图：")
print("    ", person.keys())

# 查看字典所有值的视图
print("查看字典所有值的视图：")
print("    ", person.values())

# 查看字典所有键值对的视图（类似于列表中的元组）
print("查看字典所有键值对的视图：")
print("    ", person.items())

# 修改字典”age“的值
person["age"] = 20
print("修改字典 age 的值为20：")
print("    ", person)

# 增加一个“爱好”的值
person["like"] = "football"
print("增加一个 like 的值：")
print("    ", person)

# 删除”like“的键值对
person.pop("like")
print("删除字典 like 的值：")
print("    ", person)

# 统计键值对的数量
print("统计字典的数量：")
print("    ", len(person))

# 合并字典,如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对
temp_dic = {"height": 1.75,
            "phone": 5373890,
            }
person.update(temp_dic)
print("将 temp_dic 字典合并到person字典：")
print("    ", person)

# 清空字典
temp_dic.clear()
print("清空 temp_dic 字典：")
print("    ", temp_dic)

字典操作示例

for循环遍历获取所有键值对

person = {"name": "小明",
          "age": 18,
          "city": "北京"  
          }
for k in person:
    print(k, ":", person[k])

字典和列表的应用场景

将多个字典放在一个列表中，在循环体内部针对每一个字典去做处理

字典和列表的结合应用
information_list = [{"name": "张三",
                    "age": 18,
                    "city": "北京",
                    },
                    {"name": "李四",
                    "age": 25,
                    "city": "上海",
                     },
                    ]
for i in information_list:
    print(i)
    for k in i:
        print(k,":", i[k])
定义一个列表，里面包含了两个字典，使用for循环遍历打印两个字典的值，然后嵌套for循环打印字典里的每个key和value值

字符串

字符串就是一串字符，可以使用一对 “ 或者是一对 ‘ 定义字符串。

定义字符串一般使用 双引号“” ，如果字符串本身包含双引号的时候，那么定义字符串可以使用单引号

字符串格式

str1 = "我叫张三"
str2 = '我喜欢吃"水果"'

字符串操作

分类	方法	说明
判断类型	string.isspace()	如果 string 中只包含空格，则返回True
	string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回True
	string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
	string.isdecimal()	如果 string 只包含数字则返回True，全角数字
	string.isdigit()	如果 string 只包含数字则返回True，全角数字、（1）、\u00b2
	string.isnumeric()	如果 string 只包含数字则返回True，全角数字、汉字数字
	string.istitle()	如果 string 是标题化的（每个单词首字母大写），则返回True
	string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字母都是小写，则返回True
	string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字母都是大写，则返回True
替换	string.startswith(str)	检查字符串是否以str开头，是则返回True
	string.endswith(str)	检查字符串是否以str结尾，是则返回True
	string.find(str, start=0, end=len(string))	检查str是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
	string.rfind(str, start=0, end=len(string))	类似find（）函数，不过是从右边开始查找
	string.index(str, start=0, end=len(string))	跟find（）方法类似，只不过如果str不在string中会报错
	string.rindex(str, start=0, end=len(string))	类似于index（），不过是从右边开始
	string.replace(old_str, new_str, num=string.count(old))	把string张的old_str替换成new_str，如果num指定，则替换不超过num次
大小写转换	string.capitalize()	把字符串的第一个字符大写
	string.title()	把字符串的每个单词首字母大写
	string.lower()	转换string中所有大写字符为小写
	string.upper()	转换string中所有小写字符为大写
	string.swapcase()	翻转string中的大小写
文本对齐	string.ljust(width)	返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
	string.rjust(width)	返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
	string.center(width)	返回一个原字符串剧中，并使用空格填充至长度width的新字符串
去除空白符	string.lstrip()	去除string左边（开始）的空白字符
	string.rstrip()	去除string右边（末尾）的空白字符
	string.strip()	去除string左右两边的空白字符
拆分和链接	string.partition(str)	把字符串string分成一个3元素的元组（str前面、str、str后面）
	string.rpartition(str)	类似于partition()函数，不过是从右边开始查找
	string.split(str="", num)	以str为分隔符切片string，如果num有指定值，则仅分割num+1个子字符串，str默认包含\r \t \n 和空格
	string.splitlines()	按照行（\r ,\n, \r\n）分割，返回一个包含各行作为元素的列表
	string.join(seq)	以string作为分隔符，将seq中所有的元素（的字符串表示）合并为一个新的字符串

字符串拼接（join）

nine_word = ['临', '兵', '斗', '者', '皆', '阵', '列', '在', '前']
print(nine_word)
# 以空格连接
result = ' '.join(nine_word)
print(result, "           ", "类型是:", type(result))

info1 = "My name is ZhangSan"
info2 = "18 years old"
info3 = "I'm from Beijing"
# 以逗号连接
result2 = ','.join((info1, info2, info3))
print(result2)

字符串拆分（split）
url = "https://www.baidu.com"
print(url.split("//")[-1])

字符串切片

num_str = "0123456789"
# 截取2往后的字符串
print(num_str[2:])
# 截取0~6之前的字符串
print(num_str[:6])
# 从头开始截取，每隔2位截取
print(num_str[::2])
# 从头开始截取，每隔1位截取
print(num_str[1::2])

# 从最后一个字符串开始，每取一个值都向左移动，最终得到倒序
print(num_str[-1::-1])

字符串for循环遍历

str1 = "我叫张三"
str2 = '我喜欢吃"水果"'

for i in str1:
    print(i, end=" ")
for lens in range(len(str1)):
    print(lens, end=" ")

面向对象

类是对一群具有相同特征或者是行为的事物的一个统称

就好比是制造飞机的图纸，是一个模板，飞机都有啥行为（方法），起飞、降落......；都有啥特征（属性），机翼多长多宽......

类是负责创建对象的

对象是由类创建出来的一个具体存在

就好比是用图纸制造出来的飞机

类是模板，对象是根据类这个模板创建出来的，应该先有类，在有对象

设计一个类的三要素：

类名，这类事物的名字
属性，这类事物具有什么样的特征
方法，这类事物具有什么样的行为

PIP包管理器

Pip是Python的包管理器，它允许你安装和管理额外的库和依赖，这些库和依赖未包含在Python标准库中。pip是递归的缩写，其全名是“Pip Installs Packages”或者“Pip Installs Python”。除了Python外，Pip还可以用于其他一些Python的变体，例如PyPy。

Pip的主要功能如下：

安装Python包
卸载Python包
升级Python包
查看已安装的Python包

基础命令

pip list

pip install <package_name>

pip uninstall <package_name>

pip install --upgrade <package_name>

指定源下载

pip3 install -i https://pypi.douban.com/simple/ <package_name>

国内源

清华：https://pypi.tuna.tsinghua.edu.cn/simple

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/

华中理工大学：http://pypi.hustunique.com/

山东理工大学：http://pypi.sdutlinux.org/

豆瓣：http://pypi.douban.com/simple/

下载到本地

pip3 download urlopen -d "/opt/py_packge" -i https://pypi.mirrors.ustc.edu.cn/simple/

安装本地的包

pip3 install /opt/py_packge/urlopen-1.0.0.zip

文件操作

图片操作

打开图片

Pillow是一个Python图像处理库

yum -y install libjpeg*

pip3 install -i https://pypi.mirrors.ustc.edu.cn/simple/ pillow==8.4.0

from PIL import Image

image_path = 'E:\工具\pycharm\object\jpg\p1597238857.jpg'
image = Image.open(image_path)
image.show()

移动图片

from PIL import Image

import os



#打开本地图片

image_path = '/opt/pytest/file/1.jpeg'

image = Image.open(image_path)



#显示图片

image.show()



old_directory = '/opt/pytest/file'

new_directory = '/opt/pytest/file/jpeg'



#即使目录存在，也会正常完成创建目录操作

os.makedirs(new_directory, exist_ok=True)



#将目录路径和文件名拼接成一个完整的文件路径

new_file_path = os.path.join(new_directory, '荒.jpeg')



#移动文件到新目录

os.rename(image_path,new_file_path)

print(f"文件已保存到新目录：{new_file_path}")

下载图片（爬虫）

import re

import requests
from bs4 import BeautifulSoup
import os
from PIL import Image
url = 'https://movie.douban.com/'
header = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'}

response = requests.get(url, headers=header, verify=False)
response.encoding = 'utf-8'
#print(response.text)

main_list = BeautifulSoup(response.text, "html.parser")
#print(main_list)

info_list = main_list.find("div", class_="article").find_all('a')
#print(info_list)

text = info_list

text = ''.join(str(tag) for tag in text)

# 使用 BeautifulSoup 解析 HTML
soup = BeautifulSoup(text, 'html.parser')

# 提取所有图片链接

#遍历所有的<img>标签，并将每个标签的src属性的值添加到一个新的列表中
image_links = [img['src'] for img in soup.find_all('img')]

# 输出提取到的图片链接
os.makedirs("jpg", exist_ok=True)
for link in image_links:
    jpg_name = link.split("/")[-1]
    img_data = requests.get(link).content
    with open(os.path.join("jpg", jpg_name), 'wb') as f:
        f.write(img_data)
        print(f"已下载: {jpg_name}")

print("下载完成")

发送一个GET请求到豆瓣电影网站（https://movie.douban.com/），并获取响应内容。
使用BeautifulSoup对获取到的HTML进行解析，找到网页中class为"article"的div标签下所有的超链接（a标签）。
通过 img.find('img')['src'] 的方式直接从 img 标签中提取图片链接。遍历这些超链接，提取出每个超链接中的图片链接（img标签的src属性），并存储在一个列表中。
创建一个名为"jpg"的文件夹（如果该文件夹不存在的话）来存储下载的图片。
遍历图片链接列表，使用 requests.get(link).content 获取图片的二进制数据，然后将二进制数据使用 open 方法写入以图片链接中最后一部分命名的文件中，保存在"jpg"文件夹中。

文件操作

打开文件

file_path = '/opt/pytest/file/信息笔记.txt'



#打开文件，只读模式

with open(file_path,'r') as file:

#读取文件内容

        file_content = file.read()

        print(file_content)

向文件追加内容

file_path = '/opt/pytest/file/信息笔记.txt'



with open(file_path, 'a') as file:

        file.write('加入语句1：你好！\n')

        file.write('加入语句2：再见！\n')



with open(file_path, 'r') as file:

        file_content = file.read()

        print(file_content)

练习实例

九九乘法表

# @Time     : 2023/11/17  99乘法表
for i in range(1,10):
    for j in range(1, i+1):
        result = j * i
        print(f"{j}*{i}={result}", end="\t")
    print()

输出1到100之间的所有偶数

for i in range(1, 101):
    if i % 2 == 0:
        print(i, end=" ")

计算1+2+3+......100的总和

total_sum = 0
for i in range(1, 101):
    total_sum = total_sum + i
print(total_sum)

判断分数

# @Time     :2023/11/17   判断分数70
num = float(input('输入学生的分数：'))
if num >= 90:
    print("优秀")
elif 90 > num >= 80:
    print("良")
else:
    print("有待观察")

判断验证次数

# @Time     :2023/11/17   判断验证次数
count = 3
while count > 0:
    number = 10
    num = int(input("输入数字："))
    if num == number:
        print(f"输入数字{num}正确")
        break
    else:
        count = count - 1
        if count > 0:
            if num < 10:
                print(f"输入数字{num}小了，还剩{count}次机会")
            else:
                print(f"输入数字{num}大了，还剩{count}次机会")
        else:
            print("没机会了，游戏结束")

FAQ

调试打断点

F8单步走

函数方法记不住怎么办？

记不住strip方法该如何写参数，可以使用ctrl+q来查看该方法介绍

常见报错

名字没有被定义

a = 1
print(b)

Traceback (most recent call last):

  File "E:\工具\pycharm\object\基础学习.py", line 10, in <module>

    print(b)

          ^

NameError: name 'b' is not defined