Python学习笔记_pycharm快捷输入print()

目录

Python学习笔记

（一）初始python

1.输出内容

2.退出程序

3.运行python文件中的代码

4.pycharm快捷键

（二）字面量

1.字面量含义

2.python中常用的值

3.利用print输出各种字面量

（三）注释

1.单行注释

2.多行注释

（四）变量

1.定义

2.格式

（五）数据类型

1.type()语句

（1）在print语句中，直接输出类型信息

（2）用变量存储type()的结果（返回值）

（3）使用type()语句，查看变量中存储的数据类型信息

2.数据类型转换

（六）标识符

1.标识符定义

2.标识符命名规则

（1）内容限定

（2）大小写敏感

（3）不可以使用关键字

3.变量命名规范（类、方法在后面）

（七）运算符

1.算术运算符

2.赋值运算符

（1）标准赋值运算符

（2）复合赋值运算符

---

Python学习笔记

• 第一部分——入门知识

（一）初识python

1.输出内容

print(“要输出的内容”)

如果要求print语句输出不换行在后面加上,end=''就好

例如：

print("Hello ",end='')
print("world!",end='')

2.退出程序

exit()

3.运行python文件中的代码

cmd中输入“python+空格+文件地址”（文件地址不能有空格，不然会出错）

4.pycharm快捷键

5.制表符\t

制表符\t，效果等同于在键盘上按下：tab键，它可以让我们的多行字符串进行对齐

（二）字面量

1.字面量含义

写在代码中固定的值

2.python中常用的值

3.利用print输出各种字面量

字符串需要双引号，其他类型的值不用

（三）注释

1.单行注释

#开头，右边的都是注释，不会被当作代码执行

规范要求：#后加一个空格再加注释内容

2.多行注释

"""注释内容,支持换行,多行注释"""

英文状态下的三对双引号

（四）变量

1.定义

变量：在程序运行时，能储存计算结果或表示值得抽象概念

2.格式

变量名=变量值

变量名：变量名称，也就是变量本身

=：赋值，表示将等号右侧的值赋予等号左侧的变量

变量值：每一个变量都有自己存储的值（内容），称为变量值。

# 定义一个变量，用于记录钱包余额
money = 420
# 通过print语句，输出变量记录的内容
print("钱包余额为: ", money ,"元")
# 买了仙那度巡回演唱会蓝光DVD（399元），输出目前余额
money = money - 399
print("钱包余额为: ", money ,"元")

（五）数据类型

1.type()语句

语法：type(被查看类型的数据)，type查看的时变量存储的数据的类型，本质是查看的数据的类型。在python中，变量是没有类型的。

使用方法：

（1）在print语句中，直接输出类型信息

print(type("XANADU"))
print(type(420))
print(type(2004.0408))

运行结果

（2）用变量存储type()的结果（返回值）

string_type = type("XANADU")
int_type =  type(420)
float_type = type(2004.0408)
print(string_type)
print(int_type)
print(float_type)

运行结果

（3）使用type()语句，查看变量中存储的数据类型信息

name = "XANADU"
name_type = type(name)
print(name_type)

运行结果：

2.数据类型转换

int(x)—将x转换为整数

float(x)—将x转换为浮点数

str(x)—将x转换为字符串

注意：①万物皆可字符串：任何类型都可以转变成字符串

②字符串不一定能转化为整型或浮点型

③将浮点型转化为整型会丢失精度，直接舍弃小数部分（而不是四舍五入）

（六）标识符

1.标识符定义

标识符：用户在编程的时候使用的一系列名字，用于给变量、类、方法等命名。

2.标识符命名规则

（1）内容限定

在标识符的命名中，只允许出现英文、中文、数字、下划线（_）这四类元素，其余任何内容都不被允许。

注意事项：

①不推荐使用中文

②数字不可以作为开头

（2）大小写敏感

例如XANADU和xanadu在python“眼”中是两个不一样的变量

（3）不可以使用关键字

Python中有一些单词称为关键字，关键字在python中都有特定用途，我们不可以使用它们作为标识符。常见的关键字有False、True、in、is、while、for等等，后续会陆续用到，不必死记。

3.变量命名规范（类、方法在后面）

（1）明了：见名知意，看到变量名就知道什么意思

（2）简洁：在保证“明了”前提下减少名字的长度

（3）多个单词组合变量名，要用下划线做分割

（4）命名变量中的英文字母，应全部小写

（七）运算符

1.算术运算符

2.赋值运算符

（1）标准赋值运算符

（2）复合赋值运算符

（八）字符串

1.字符串的三种定义方式

（1）单引号定义法

string1= '我爱python'

（2）双引号定义法

string2= "我爱python"

（3）三引号定义法

string3 = '''我爱python'''

需要注意的是，对于三引号定义法，如果使用变量接受，它就是字符串，并且支持换行。如果未使用变量接受，它就是注释

（4）字符串的引号嵌套

①单引号内使用双引号（针对字符串包含双引号的情况）

# 在字符串内包含双引号
string1 = '"我爱python"'
print("string1="+string1)

②双引号内使用单引号（针对字符串包含单引号的情况）

# 在字符串内包含单引号
string2= "'我爱python'"
print("string2="+string2)

 ③使用转义字符（通用）

# 使用转义字符/进行转义
string3 = "\'我爱python\""
print("string3="+string3)

运行结果

2.字符串的拼接(+)

（1）字面量之间的拼接

# 进行字面量的拼接
name = "Python小白"
print("我是"+name)

（2）字面量与变量之间的拼接

如果变量是字符串，可以通过+拼接。如果不是字符串就不能使用+。

# 进行字面量与变量的拼接
age = 19
print("我的年龄是",age)

（3）字符串格式化

①.方法1—占位

Python中最常用的三类数据类型占位：

！！！注意：多个变量占位，变量要用括号括起来，并按照占位的顺序来填入

代码示例:

# 通过占位的形式，完成字符串拼接
name = "Python小白"
print("我是%s" % name)
# 通过占位形式，完成数字和字符串的拼接
name = "Python小白"
telephone_number = 19970420233
print("我是%s,我的手机号码是:%s"%(name,telephone_number))
# %d、%f的使用
name = "AMG"
setup_year = 2000
stock_price = 19.99
message = "%s,成立于%d,股价是：%f"%(name,setup_year,stock_price)
print(message)

运行结果

方法2—f（没有类型要求，不做精度控制）

格式：f”内容{变量}”

代码示例：

name = "AMG"
setup_year = 2000
stock_price = 19.99
print(f"我是{name},我成立的年份是{setup_year},我的股价是{stock_price}")

运行截图：

②.格式化的精度控制

方法：使用辅助符号“m.n”来控制数据的宽度和精度

m：控制宽度，要求是数字（很少使用），设置的宽度小于数字自身不生效

.n：控制小数点精度，要求是数字，会进行小数的四舍五入

小数点和小数部分也算入宽度计算。如，对11.35设置了%7.2f后，结果是：[空格][空格]11.35，两个空格补足宽度，小数部分限制2位精度后进行四舍五入。

代码演示：

num1=11
num2=11.345
print("数字11宽度限制5，结果：%5d"%num1)
print("数字11宽度限制1，结果：%1d"%num1)
print("数字11.345宽度限制7，小数精度2，结果：%7.2f"%num2)
print("数字11.345不限制宽度，小数精度2，结果：%.2f"%num2)

运行结果：

③.对表达式进行字符串格式化

表达式就是一条具有明确执行结果的代码语句，在无需使用变量存储数据的时候可以直接格式化表达式简化代码。

方法：f"{表达式}"或"%s/%d/%f"%(表达式)

代码示例:

print("1+1的结果是：%d"%(1+1))
print(f"1*2的结果是{1*2}")
print("字符串在python中的类型名是%s"%(type("string")))

字符串格式化练习题：

参考代码:

name = "AMG"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_growth_factor = 1.2
growth_days = 7
after_growth_price = stock_price*stock_price_daily_growth_factor**7
print(f"公司：{name},股票代码：{stock_code},当前股价：{stock_price}")
print("每日增长系数是：%.1f,经过%d的增长后，股价达到了：%5.2f"%(stock_price_daily_growth_factor,growth_days,after_growth_price))

运行结果:

（九）数据输入（input语句）

1.input()语句的功能是获取键盘输入的数据

2.可以使用：input(提示信息)，用以在使用者输入内容之前显示提示信息

3.注意：无论键盘输入什么类型的数据，获取到的数据永远是字符串类型

# 输入数字类型
num = input("请告诉我你的银行卡密码：")
print("你的银行卡密码的类型是：",type(num))

 运行结果：

如果要得到数字类型，就要进行数据类型转换

# 输入数字类型
num = input("请告诉我你的银行卡密码：")
# 数据类型转换
num = int(num)
print("你的银行卡密码的类型是：",type(num))

运行结果：

（十）布尔类型

1.自行定义布尔类型

布尔类型的字面量：

1. True：表示真（是、肯定）
2. False：表示假（否、否定）

定义变量存储布尔类型数据

变量名称 = 布尔类型字面量

代码演示：

# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是{bool_1}，类型是{type(bool_1)}")
print(f"bool_2变量的内容是{bool_2}，类型是{type(bool_2)}")

运行结果：

2.通过比较运算符得到布尔类型的结果

布尔类型的数据不仅可以通过定义得到，还可以通过比较运算符进行内容比较得到

代码演示：

# 比较运算符的使用 ==,!=,>,<,>=,<=
# 演示进行内容相等的比较（注意是两个等号）
num1 = 10
num2 = 10
print(f"10==10的结果是：{num1 == num2}")
 
num1 = 10
num2 = 15
print(f"10!=15的结果是：{num1 != num2}")
 
name1 = "XANADU"
name2 = "xanadu"
print(f"XANADU==xanadu的结果是：{name1 == name2}")
 
# 演示“>,<,>=,<=”的比较运算
num1 = 10
num2 = 5
print(f"10>5的结果是：{num1 > num2}")
print(f"10<5的结果是：{num1 < num2}")
 
num1 = 10
num2 = 10
print(f"10>=10的结果是：{num1 >= num2}")
print(f"10<=10的结果是：{num1 <= num2}")

运行结果：

（十一）判断语句

1.if语句的基本格式

基本语法：

if 要判断的条件:

                条件成立时，要做的事情

注意：①.冒号不要丢

②.归属于if语句的代码块，需在前方填充4个空格缩进

# 定义变量
age = 26
# 进行判断
if age>=18:
    print("已成年")

小练习：

参考代码：

# 欢迎语句
print("欢迎来到黑马儿童游乐场，儿童免费，成人收费。")
# 获取键盘输入
age =  input("请输入你的年龄:")
age = int(age)
# 通过if判断是否为成年人
if age>=18:
    print("您已成年，游玩需要补票10元。")
print("祝您游玩愉快")

2.if else语句

基本语法:

if 条件:

                满足条件时要做的事情1

                满足条件时要做的事情2

                满足条件时要做的事情3

                ...（省略）...

else:

                不满足条件时要做的事情1

                不满足条件时要做的事情2

                不满足条件时要做的事情3

                ...（省略）...

注意：①else后的代码块，需在前方填充4个空格缩进

②else不需要判断条件

③冒号不要丢

代码示例：

# 欢迎语句
 
print("欢迎来到儿童游乐场，儿童免费，成人收费。")
 
# 获取键盘输入
 
age =  input("请输入你的年龄:")
 
age = int(age)
 
# 通过if判断是否为成年人
 
if age>=18:
 
    print("您已成年，游玩需要补票10元。")
 
else:
 
    print("您未成年，可以免费游玩。")
 
print("祝您游玩愉快！")

3.if elif else语句

基本语法：
if 条件1:

                满足条件1时要做的事情

                满足条件1时要做的事情

                ......

elif 条件2:

                满足条件2时要做的事情

                满足条件2时要做的事情

.                .....

elif 条件n:

                满足条件n时要做的事情

                满足条件n时要做的事情

                ......

else:

                所有条件都不满足应做的事情

                所有条件都不满足应做的事情

                ......

注意：①判断是互斥且有顺序的，上一个满足后面就不会进行判断了

②else可以省略不写，效果等同于前面n个独立的if判断

③空格缩进仍然要有，冒号不要忘记

④可以在条件判断中直接写input语句节省代码量

代码示例：

# 定义一个变量数字
 
guess_number = 10
 
#通过键盘输入猜想的数字，通过多次if和elif的组合进行猜想比较
 
if int(input("请输入第一次猜想的数字：") == guess_number):
 
    print("恭喜你猜对啦！我想的就是10")
 
elif int(input("不对，再猜一次：") == guess_number):
 
    print("恭喜你猜对啦！我想的就是10")
 
elif int(input("不对，再猜最后一次：") == guess_number):
 
    print("恭喜你猜对啦！我想的就是10")
 
else:
 
    print("Sorry，全部猜错啦，我想的是10")

运行结果：

 

4.判断语句嵌套

基础语法格式：

if 条件1:

                满足条件1做的事情1

                满足条件1做的事情2

                if 条件2:

                                满足条件2做的事情1

                                满足条件2做的事情2

如上，第二个if，属于第一个if内，只有第一个if满足条件才会执行第二个if

注意：①.嵌套判断语句可以用于多条件、多层次的逻辑判断

②.嵌套判断语句可以根据需求，自由组合if elif else来构建多层次判断

③.嵌套判断语句一定要注意空格缩进，Python通过空格缩进来决定层次关系

代码示例：

# 构建一个随机的数字变量
 
import random
 
num = random.randint(1,10)
 
 
 
guess_number = int(input("请输入你猜测的数字:"))
 
# 通过if判断语句将进行数字猜测
 
if guess_number == num:
 
    print("恭喜第一次就猜中了！")
 
else:
 
    if guess_number > num:
 
        print("你猜测的数字大了")
 
    else:
 
        print("你猜测的数字小了")
 
 
 
    guess_number = int(input("再次输入你猜测的数字:"))
 
    if guess_number == num:
 
        print("恭喜猜中了！")
 
    else:
 
        if guess_number > num:
 
            print("你猜测的数字大了，还有最后一次机会")
 
        else:
 
            print("你猜测的数字小了，还有最后一次机会")
 
 
 
        guess_number = int(input("再次输入你猜测的数字（注意这是最后一次机会）:"))
 
        if guess_number == num:
 
            print("恭喜猜中了！")
 
        else:
 
            if guess_number > num:
 
                print("三次机会用完了，没有猜中")

运行截图：

 

（十二）循环语句

1．While循环

（1）while循环基础知识

基础语法：

while 条件：

                条件满足时，做的事情1

                条件满足时，做的事情2

                条件满足时，做的事情3

                ...（省略）...

注意：①只要条件满足，循环就会一直进行

②while的循环条件需得到布尔类型，True表示继续循环，False表示结束循环

③需要设置循环终止的条件，如i += 1配合i<100，就能确保100次后停止（i初始值为0），否则将无限循环

④空格缩进和if判断一样，都需要设置

代码示例：

i = 1
sum = 0
while i<=100:
    sum += i
    i+=1
print("sum is %s"%sum)

运行结果：

 

（3）案例使用—打印九九乘法表

代码示例：

# 定义外层循环的控制变量
i = 1
while i <= 9:
    # 定义内层循环的控制变量
    j = 1
    while j<=i:
        # 内层循环的print语句不换行，通过\t进行对齐
        print(f"{j}*{i}={i*j}\t",end='')
        j += 1
    i += 1
    print() # print空内容，就是输出一个换行

运行结果：

2.for循环

（1）基础语法

for 临时变量 in待处理的数据集：

                循环满足条件时执行的代码

注意：①for循环是将字符串的内容：依次取出

②同while循环不同，for循环无法定义循环条件，只能从被处理的数据集中依次取出内容进行处理。

③循环内的语句需要有空格缩进。

示例代码：

name = "All I have to do is nothing but to be brave."
# 定义一个变量用于记录name中o出现的次数
count = 0
# for循环统计
for temp in name:
    if temp == 'o':
        count +=1
print(f"name中共有{count}个字母o")

运行结果：

（2）range语句

功能：获取一个数字序列，与for循环结合可以确定for循环的执行次数

语法：①range（num）

表示从0开始，到num结束（不含num本身）

②range（num1，num2）

表示从num1开始，到num2结束（不含num2本身）

③range（num1，num2，step）

表示从num1开始，到num2结束（不含num2本身），步长以step为准

（3）嵌套使用

基础语法：

for 临时变量 in待处理的数据集：

                循环满足条件时执行的代码1

                循环满足条件时执行的代码2

                循环满足条件时执行的代码3

                ……

                for 临时变量 in待处理的数据集：

                        循环满足条件时执行的代码1

                        循环满足条件时执行的代码2

                        循环满足条件时执行的代码3

                        ……

注意：①注意空格缩进，嵌套for循环同样通过索金莱确定层次关系

②for循环和while循环可以相互嵌套使用

# 通过外层循环控制行数
for x in range(1,10):
    # 通过内层循环控制每一行的输出
    for y in range(1,x+1):
        print(f"{y}*{x}={x*y}\t",end='')
    print()

（4）continue（临时中断）和break（直接结束）

①continue

continue的嵌套使用：
如下，语句1、语句2和语句4都可以执行，但是语句3不行

②break

（5）综合练习

参考代码：

# 练习案例：发工资
import random
# 定义账户余额
count_money = 10000
# 利用for循环发放工资
for i in range(1,21):
    if count_money == 0:
        print("工资发完了，下个月领取吧。")
        break
    score = random.randint(1, 10)
    # 判断绩效
    if score < 5:
        print(f"员工{i},绩效分{score},不发工资，下一位。")
        # 跳过绩效分不足的员工
        continue
    else:
        count_money -= 1000
        print(f"向员工{i}发放工资1000元，账户余额还剩{count_money}")

运行结果：

（十三）函数

1.基础知识

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

为什么使用函数：为了得到一个针对特定需求、可供重复利用的代码段提高程序的复用性，减少重复代码，提高开发效率。

（1）函数的基础定义语法

函数的定义：

def 函数名（传入参数）：

               函数体（函数要做的事情）

                return 返回值

函数的调用：函数名（参数）

注意事项：①参数如不需要，可以省略

②返回值如不需要，可以省略

③函数必须先定义后使用

2.函数的传入参数

功能：在函数进行计算的时候，接受外部（调用时）提供的数据

基于函数的定义语法(注意缩进）：
def 函数名（传入参数）：

                函数体

                return 返回值

代码示例：

# 定义两数相加的函数，通过参数接受被计算的两个数字
def add(x,y):
    result = x + y
    print(f"{x}+{y}的结果是{result}")
# 调用函数，传入被计算的2个数字
add(1997,420)

解析：

函数定义中，提供的x和y称为形式参数（形参），表示函数声明将要使用2个参数，参数之间使用逗号进行分隔。

函数调用中，提供的1997和420，称之为实际参数，表示函数执行时真正使用的参数值，传入的时候按照顺序传入数据使用逗号分隔。

注意：传入参数的数量是不受限制的，可以不使用参数，也可以使用n个参数。

练习案例：

参考代码：

# 定义体温监测函数
def check(x):
    if x <= 37.5:
        print(f"体温监测中，您的体温是:{x}，体温正常请进！")
    else:
        print(f"体温监测中，您的体温是:{x}，需要隔离！")
# 调用函数
print("请输入您的体温：")
x = input()
x = float(x)
check(x)

3.函数的返回值

（1）基本定义

解释：程序中函数完成事情过后给调用者的结果

语法格式：
def 函数（参数…）

        函数体

        Return 返回值

变量 = 函数（参数）

注意：函数体在遇到return语句后就结束了，所以写在return后的代码不会执行。

（2）None类型

Python中特殊的字面量：None，其类型是：<class.'NoneType'>

无返回值的函数实际上就是返回了None这个字面量。

应用场景：

• 用在函数无返回值上
• 在if判断中，None等同于False

一般用于在函数中主动返回None，配合if判断做相关处理

示例代码：

# None用于if判断
def check_age(age):
    if age > 18:
        print("SUCCESS")
    else:
        return None
 
result = check_age(16)
if not result:
    # 进入if表示result是None值，也就是False
    print("未成年不可以进入")

运行结果：
未成年不可以进入

• 用于声明无内容的变量上

定义变量，但赞数不需要变量有具体值，可以用None来代替

示例代码：name = None

4.说明文档

对函数进行说明解释，帮助更好理解函数的功能

：param用于解释参数

：return用于解释返回值

示例代码：

def add(x,y):
    """
    add函数可以接受两个参数，进行两数相加的功能
    :param x: 形参x表示相加的其中一个数字
    :param y: 形参y表示相加的另一个数字
    :return: 返回值是两数相加的结果
    """
    result = x+y
    print(f"x+y=:{result}")
    return (result)

（十四）数据容器

1.基础知识

数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素可以是任意类型的数据，如字符串、数字、布尔等。

数据容器的分类：数据容器根据特点的不同，如“是否指出重复元素”、“是否可以修改”等分为五类，分别是：列表（list）、远组（tuple）、字符串（str）、集合（set）、字典（dict）。

2.列表（list）

（1）列表的定义

基本语法：

# 字面量

[元素1，元素2，元素3，元素4……]

# 定义变量

变量名称=[元素1，元素2，元素3，元素4……]

# 定义空列表

变量名称=[]

变量名称=list()

注意：①列表内的每一个数据称为元素，以[]作为标识，列表内的每一个元素用逗号隔开

②元素类型没有任何限制，甚至可以是列表，这样就构成了嵌套列表

示例代码：

# 定义一个列表list
my_list=["Xin Liu",26,"女"]
print(my_list)
print(type(my_list))
 
# 定义一个嵌套的列表
my_list=[[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

运行结果：

（2）列表的下标（索引）

正向：

示例代码：

# 通过下标索引取出对应位置的元素
my_list = ["Tom","Lily","Rose"]
# 列表[下标索引],从前往后从0开始，每次+1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范，不能超出范围！！！
print(my_list[3])
 

运行结果：

 反向：

示例代码：

# 通过下标索引取出对应位置的元素
my_list = ["Tom","Lily","Rose"]
# 列表[下标索引],从后往前开始。从-1开始，每次-1
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

运行结果：

嵌套：

示例代码：

# 取出嵌套列表的元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[1][1])

运行结果：5

（3）列表的常用操作

方法和函数功能一样，有传入参数和返回值，只是方法的使用格式不同

函数的使用：num = add(1,2)

方法的使用：student=Student()

num = student.add(1,2)

a.查询某元素的下表

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index（元素）

index就是列表对象（变量）内置的方法（函数）

示例代码：

my_list = ["Tom","Lily","Rose"]
# 查找某元素在列表内的下标索引
index1 = my_list.index("Tom")
print(f"Tom在列表中的下标索引是：{index1}")
# 若查找的元素不存在
index2 = my_list.index("XANADU")
print(f"XANADU在列表中的下标索引是：{index2}")

运行结果：

②修改特定位置（索引）的元素值

示例代码：

my_list = ["Tom","Lily","Rose"]
# 修改特定下标的元素值
my_list[1]="XANADU"
print(f"列表被修改后结果是：{my_list}")

运行结果：

c.插入元素

语法：列表.insert(下标，元素),在指定的下标位置插入指定的元素

示例代码：

my_list = ["Tom","Lily","Rose"]
# 插入元素
my_list.insert(0,"XANADU")
print(f"列表插入元素后结果是：{my_list}")

运行结果：

d.追加元素

语法：列表append（元素），将指定元素追加到列表尾部

示例代码：

my_list = ["Tom","Lily","Rose"]
# 追加元素
my_list.append("XANADU")
print(f"列表追加元素后结果是：{my_list}")

运行结果：列表追加元素后结果是：['Tom', 'Lily', 'Rose', 'XANADU']

追加元素方法2：

语法：列表.extend(其他数据容器)，将其他数据容器的内容取出来，依次追加到列表尾部

示例代码：

my_list = ["Tom","Lily","Rose"]
# 追加元素2
my_list2 = [1,2,3]
my_list.extend(my_list2)
print(f"列表追加新的列表后结果是：{my_list}")

运行结果：列表追加新的列表后结果是：['Tom', 'Lily', 'Rose', 1, 2, 3]

e.删除

语法1 ：del列表[下标]

语法2 ：列表.pop（下标）—可以得到返回值

示例代码：

my_list = ["Tom","Lily","Rose"]
# 删除元素
# 方法1:del列表[下标]
del my_list[1]
print(my_list)
#方法2:列表.pop（下标）
element = my_list.pop(0)
print(f"取出的元素是{element}，取出后列表为{my_list}")

运行结果：

['Tom', 'Rose']

取出的元素是Tom，取出后列表为['Rose']

f.删除某元素在列表中的第一个匹配项

语法：列表.remove（元素）

示例代码：

my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
# 删除某元素在列表中的第一个匹配项
my_list.remove("Lily")
print(my_list)

运行结果：['Tom', 'Rose', 'Tom', 'Lily', 'Rose']

g.清空列表

语法：列表.clear()

示例代码：

my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
# 清空列表
my_list.clear()
print(my_list)

运行结果：[]

h.统计某元素在列表中的数量

语法：列表.count()

示例代码：

my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
count = my_list.count("Rose")
print(f"列表中Rose的数量是{count}")

运行结果：列表中Rose的数量是2

i.统计列表内元素个数

语法：len(列表)

示例代码：

my_list = ["Tom","Lily","Rose","Tom","Lily","Rose"]
print(f"列表中元素个数为{len(my_list)}")

运行结果：列表中元素个数为6

（4）列表特点

①可容纳多个元素

②可容纳不同类型的元素

③数据是有序存储的（有下标序号）

④允许重复数据存在

• 可以修改元素

（5）列表的遍历

①while循环

示例代码：

# while循环遍历列表元素
# 定义函数
def list_while_func(my_list):
  index = 0
  while index < len(my_list):
    element = my_list[index]
    index += 1
    print(element)
# 调用函数
my_list = ["战斗到最后！","GoGo!!!","下一个绿洲！","HopeHope!!!"]
list_while_func(my_list)

运行结果：

战斗到最后！

GoGo!!!

下一个绿洲！

HopeHope!!!

②for循环

语法：

for 临时变量 in 数据容器：

    对临时变量进行处理

表示从容器内依次取出元素并赋值到临时变量上。在每一次循环中，我们可以对临时变量（元素）进行处理。

示例代码：

# for循环遍历列表元素
# 定义函数
def list_for_func(my_list):
  for element in my_list:
    print(element)
# 调用函数
my_list = ["战斗到最后！","GoGo!!!","下一个绿洲！","HopeHope!!!"]
list_for_func(my_list)

运行结果：与上一个代码运行结果一致

③for循环与while循环比较：

a.while循环和for循环，都是循环语句，但细节不同在循环控制上:while循环可以自定循环条件，并自行控制。for循环不可以自定循环条件，只可以一个个从容器内取出数据在无限循环上。

b.while循环可以通过条件控制做到无限循环，for循环理论上不可以，因为被遍历的容器容量不是无限的在使用场景上。

c.while循环适用于任何想要循环的场景for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

3.元组

元组和列表一样，都是可以封装多个、不同类型的元素在内，但是元组一旦定义完成就不可以被修改

（1）基础知识

定义语法：元组使用小括号定义，且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 定义元组字面量

（元素，元素，元素，元素，元素，元素……元素，元素）

# 定义元组变量

变量名称 = （元素，元素，元素，元素，元素，元素……元素，元素）

# 定义空元组

变量名称 = （）       #方式1

变量名称 = tuple（）  #方式2

示例代码：

# 定义元组
t1 = (420,"XinLiu",True)
t2 = ()
t3 = tuple()
# 打印出来
print(f"t1的类型是：{type(t1)},内容是{t1}")
print(f"t2的类型是：{type(t2)},内容是{t2}")
print(f"t3的类型是：{type(t3)},内容是{t3}")
# 定义单个元素的元素:一定要在后面加一个单独的逗号！！！
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},内容是{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是{t5}")
# 下标索引去取出内容
element = t5[1][2]
print(element)

运行结果：

t1的类型是：<class 'tuple'>,内容是(420, 'XinLiu', True)

t2的类型是：<class 'tuple'>,内容是()

t3的类型是：<class 'tuple'>,内容是()

t4的类型是：<class 'tuple'>,内容是('hello',)

t5的类型是：<class 'tuple'>,内容是((1, 2, 3), (4, 5, 6))

6

（2）元组的相关操作

示例代码：

# 定义元组
t1 = (420,"XinLiu",True,420,"XinLiu",True)
# 元组的操作：index查找方法
index = t1.index("XinLiu")
print(f"在t1中查找XinLiu对应的下标是{index}")
# 元组的操作：count查找方法
count = t1.count("XinLiu")
print(f"在t1中统计XinLiu的数量是{count}")
# 元组的操作：len统计元组中元素数量
num = len(t1)
print(f"t1中元素数量是{num}")

运行结果：

在t1中查找XinLiu对应的下标是1

在t1中统计XinLiu的数量是2

t1中元素数量是6

（3）元组的遍历

for循环和while循环

示例代码：

# 定义元组
t1 = (420,"XinLiu",True)
# for循环
print("-----for循环-----")
for element in t1:
    print(element)
# while循环
print("----while循环----")
index = 0
while index<len(t1):
    print(t1[index])
    index += 1

运行结果：

-----for循环-----

420

XinLiu

True

----while循环----

420

XinLiu

True

（4）特点

①可容纳多个元素

②可容纳不同类型的元素

③数据是有序存储的（有下标序号）

• 允许重复数据存在
• 元组的元素是不可以修改的！也有特例，可以修改内部list内的元素

 4.字符串（数据容器视角下）

（1）字符串的下标索引

（2）字符串的修改

同元组一样，字符串是一个无法修改的数据容器。

所以:修改指定下标的字符(如:字符串[0]=“a”)、移除特定下标的字符(如:del字符串[0]、字符串.remove()、字符串.pop()等)、追加字符等(如:字符串.append())均无法完成。

（3）字符串的常用操作

①查找特定字符串的下标索引值

语法:字符串.index(字符串)

②字符串的替换

语法:字符串.replace(字符串1，字符串2)

功能:将字符串内的全部:字符串1，替换为字符串2

注意:不是修改字符串本身，而是得到了一个新字符串哦

示例：

my_str = "XANADU永不落幕"
# replace方法
my_new_str = my_str.replace("XANADU","仙那度")
print(f"\"{my_str}\"进行替换后得到\"{my_new_str}\"")

运行结果："XANADU永不落幕"进行替换后得到"仙那度永不落幕"

③字符串的分割

语法:字符串.split(分隔符字符串)

功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存列表对中

注意:字符串本身不变，而是得到了一个列表对象

示例：

my_str = "hello python fighting!"
# split方法
my_new_str = my_str.split(" ")
print(f"\"{my_str}\"进行split切分后得到\"{my_new_str}\"，类型是{type(my_new_str)}")

运行结果：

"hello python fighting!"进行split切分后得到"['hello', 'python', 'fighting!']"，类型是<class 'list'>

④字符串的规整操作(去前后空格或回车符)

语法:字符串.strip()

my_str =" itheima and itcast "

print(my_str.strip())

#结果:"itheima and itcast

字符串的规整操作(去前后指定字符串)

语法:字符串.strip(字符串)

my_str ="12itheima and itcast21"

print(my_str.strip("12"))

#结果:"itheima and itcast"

注意，传入的是“12”其实就是:“1”和“2”都会移除，是按照单个字符。

示例：

my_str = "  hello python and fighting!  "
# strip方法
my_new_str = my_str.strip()
print(f"\"{my_str}\"进行strip操作后得到\"{my_new_str}\"")
my_str2 = "33hello python and fighting!3"
my_new_str2 = my_str.strip("33")
print(f"\"{my_str2}\"进行strip操作后得到\"{my_new_str2}\"")

运行结果：

"  hello python and fighting!  "进行strip操作后得到"hello python and fighting!"

"33hello python and fighting!3"进行strip操作后得到"  hello python and fighting!  "

⑤利用count方法统计字符串中某字符串出现次数

my_str = "hello python and fighting!"
# count方法
count = my_str.count("h")
print(f"{my_str}中\"h\"出现的次数是{count}")

运行结果：

hello python and fighting!中"h"出现的次数是3

⑥length方法统计

my_str = "hello python and fighting!"
# len方法
num = len(my_str)
print(f"{my_str}的长度是{num}")

运行结果：

hello python and fighting!的长度是26

（4）字符串的特点

只可以存储字符串

长度任意(取决于内存大小)

支持下标索引

允许重复字符串存在不可以修改(增加或删除元素等)

支持for循环

5.数据容器（序列）的切片操作

序列支持切片，即:列表、元组、字符串，均支持进行切片操作

切片:从一个序列中，取出一个子序列

语法:序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

1. 步长1表示，一个个取元素
2. 步长2表示，每次跳过1个元素取
3. 步长N表示，每次跳过N-1个元素取
4. 步长为负数表示，反向取(注意，起始下标和结束下标也要反向标记)

注意，此操作不会影响序列本身，会得到新的序列。

示例代码：

# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5]
result1 = my_list[1:4]   # 步长默认为1 ，可以不写
print(f"结果1：{result1}")
 
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]    # 起始和结束不屑表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")
 
# 对字符串进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
 
# 对字符串进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]   # 等同于将序列反转
print(f"结果4：{result4}")
 
# 对list进行切片，从3开始，1结束，步长-1
my_list = [0,1,2,3,4,5]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")
 
# 对tuple进行切片，从头开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

运行结果：

结果1：[1, 2, 3]

结果2：(0, 1, 2, 3, 4, 5, 6)

结果3：0246

结果4：76543210

结果5：[3, 2]

结果6：(6, 4, 2, 0)

6.set集合

（1）基本语法

# 定义集合字面量

{元素，元素，……，元素}

# 定义集合变量

变量名称 = {元素，元素，……，元素}

# 定义空集合

变量名称 = set（）
示例：

# 定义一个基础的集合
my_set = {"one","two","three","one","two","three","one","two","three"}
print(my_set)
my_set_empty = {}
print(my_set_empty)

运行结果：

{'two', 'one', 'three'}

{}

结论：①集合时无序的 ②集合有去重功能

（2）集合的常用操作

①修改

代码示例：

# 定义一个基础的集合
my_set = {"one","two","three","one","two","three","one","two","three"}
# 添加新元素
my_set.add("four")
my_set.add("one")
print(my_set)

运行结果：
{'two', 'one', 'three', 'four'}

②移除元素

 

 ③从集合中随机取出元素

语法：集合.pop()

功能：从集合中随机取出一个元素

结果：会得到一个元素的结果，同时集合本身被修改，元素被移除

示例：

# 定义一个基础的集合
my_set = {"one","two","three","one","two","three","one","two","three"}
# 随机取出元素
element = my_set.pop()
print(f"集合被取出的元素是{element}")
print(f"集合现在的内容是：{my_set}")

运行结果：

集合被取出的元素是three

集合现在的内容是：{'one', 'two'}

③清空集合

语法：集合.clear()

④取出两个集合的差集

语法：集合1.difference（集合2）

功能：取出两个集合的差集（集合1有而集合2没有的）

结果：得到一个新集合，集合1和集合2不变

示例：

# 取两个集合的差集
set1 = {0,1,2,3,4}
set2 = {1,3}
set3 = set1.difference(set2)
print(f"取出差集后的结果是{set3}")
print(f"取出差集后，set1的结果是{set1}")
print(f"取出差集后，set2的结果是{set2}")

运行结果：

取出差集后的结果是{0, 2, 4}

取出差集后，set1的结果是{0, 1, 2, 3, 4}

取出差集后，set2的结果是{1, 3}

⑤消除2个集合的差集

语法：集合1.difference_update（集合2）

功能：对比两个集合，在集合1内删除与集合2相同的元素

结果：集合1被修改，集合2不被修改

示例：

# 消除两个集合的差集
set1 = {0,1,2,3,4}
set2 = {1,3}
set1.difference_update(set2)
print(f"消除差集后，set1的结果是{set1}")
print(f"消除差集后，set2的结果是{set2}")

运行结果：

消除差集后，set1的结果是{0, 2, 4}

消除差集后，set2的结果是{1, 3}

⑥合并集合

语法：集合1.union（集合2）

功能：将两集合合并成新集合

结果：得到新集合，集合1与集合2不变

示例：

# 消除两个集合的差集
set1 = {0,1,2,4}
set2 = {1,3}
set3 = set1.union (set2)
print(f"合并集合后，新集合set3的结果是：{set3}")
print(f"合并差集后，set1的结果是{set1}")
print(f"合并差集后，set2的结果是{set2}")

运行结果：

合并集合后，新集合set3的结果是：{0, 1, 2, 3, 4}

合并差集后，set1的结果是{0, 1, 2, 4}

合并差集后，set2的结果是{1, 3}

⑦统计集合元素数量

语法：集合.len()

示例：

set1 = {0,1,2,4,0,1,2,4}
num = len(set1)
print(f"集合的元素个数是{num}")

运行结果：

集合的元素个数是4

⑧集合的遍历

可以使用for循环，while不可以（存疑）

示例：

set1 = {0,1,2,4,0,1,2,4}
for element in set1:
    print(f"集合的元素有{element}")

运行结果：

集合的元素有0

集合的元素有1

集合的元素有2

集合的元素有4

（3）集合的特点

①可以容纳多个数据

②可以容纳不同类型的数据

③数据时无序存储的（不支持下标索引）

④不允许重复数据存在

⑤可以修改（增加或删除元素等）

⑥支持for循环

目录

Python学习笔记

（一）初始python

1.输出内容

2.退出程序

3.运行python文件中的代码

4.pycharm快捷键

（二）字面量

1.字面量含义

2.python中常用的值

3.利用print输出各种字面量

（三）注释

1.单行注释

2.多行注释

（四）变量

1.定义

2.格式

（五）数据类型

1.type()语句

（1）在print语句中，直接输出类型信息

（2）用变量存储type()的结果（返回值）

（3）使用type()语句，查看变量中存储的数据类型信息

2.数据类型转换

（六）标识符

1.标识符定义

2.标识符命名规则

（1）内容限定

（2）大小写敏感

（3）不可以使用关键字

3.变量命名规范（类、方法在后面）

（七）运算符

1.算术运算符

2.赋值运算符

（1）标准赋值运算符