pycharm设置

设置界面主题

文件=>设置=>外观与行为=>外观=>主题

调整字体大小

• 设置=>编辑器=>字体=>大小

• 设置=>编辑器=>常规=>使用滚轮=>所有编辑器

安装插件

• 设置=>插件=>Marketplace

基础

print打印

xxxxxxxxxx
2
1
print("Hello World")
2
print("Hello Python")

print函数执行后，默认输出后是换行，如果不想换行可以添加参数 end = “”

xxxxxxxxxx
11
1
print("张三")
2
print("年龄是18岁")
3
# 运行结果 
4
# 张三
5
# 年龄是18岁
6

7
print("张三",end="")
8
print("年龄是18岁")
9

10
# 运行结果
11
# 张三年龄是18岁

print可以打印多个数据

xxxxxxxxxx
7
1
a = 100
2
b = 200
3
c = 300
4
print(a ,b ,c) 
5

6
# 运行结果
7
#100 200 300

注释

使用格式

• 单行注释 一行的前面加上#

• 多行注释 用 """ """ 或者 ''' '''

使用场景

• 添加说明的时候

• 将指定代码的功能取消，使其不在代码中生效

使用快捷键

选中需要注释的内容 然后输入组合键 ctrl + /

标识符

简单理解 为一些自定义的数据起的名字

xxxxxxxxxx
7
1
# 1.只能有数字，字母，_(下划线)组成
2
# 2.不能以数字开头
3
# 3.不能是关键字
4
# 4.区分大小写
5

6
# 下划线 first_name
7
# 驼峰命名法  单驼峰firstName 双驼峰FirstName

算数运算符

xxxxxxxxxx
12
1
# 算数运算符 + - * /
2
print(100+11000)
3
print(100-11000)
4
print(3*6)
5
print(10/6)
6

7
# 取整除 两个整数相除后，取整数部分       //
8
print(10//6)
9
# 取余数 两个整数相除后，取结果的余数部分  %
10
print(10%6)
11
# 乘方 计算a的b次方 **
12
print(2**10)

比较运算符

比较运算是发生在两个同类型数据间的一种操作，比较运算是对两个数据通过比较运算符进行比对，如果比较运算结果成立得到结果True,如果不成立，得到结果False

xxxxxxxxxx
26
1
a = 3
2
b = 5
3
# 比较两个变量大小  大于号> 小于<
4
a<b   # 成立 返回True   #判断左边的值是否小于右边的值，成立True，返回False
5
a>b   # 不成立 返回False #判断左边的值是否大于右边的值，成立True，返回False
6

7

8
a = 1
9
b = 3
10
# >= 大于或等于  <=小于或等于
11
a<=b   # 成立 返回True  #判断左边的值是否小于等于右边的值，成立True，返回False
12
a>=b   # 不成立 返回False #判断左边的值是否大于等于右边的值，成立True，返回False
13

14
# 你出去买东西，想买一个苹果笔记本 9999
15
# money == 9999    money > 9999
16

17
# ==
18
# 判断两个值是否相等 相等返回True  不相等返回False
19
a = 5
20
b = 6
21
# a == b 返回False
22

23
# !=
24
a = 5
25
b = 6
26
# a != b 返回True

逻辑运算符

xxxxxxxxxx
4
1
常见的逻辑运算符有三个 and or not
2
and 条件必须同时满足才为真，并且的意思
3
or 只要有一个条件满足就为真，是或的意思
4
not 取反对立

xxxxxxxxxx
15
1
# and
2
# 两门成绩都能考到80分以上，就买苹果笔记本
3
score1 = 82
4
score2 = 85
5
print(score1 > 80 and score2 > 80) # True
6

7
# or
8
# 两门成绩，只要有一门成绩不及格，被挨揍
9
score1 = 82
10
score2 = 58
11
print(score1 < 60 or score2 < 60) # True
12

13
# not
14
# 取相反的结果
15
print(not 20 > 10) # False

变量

变量概念

变量用于描述计算机中的数据存储空间

变量作用

在计算机中运行的程序中保存数据

语法格式

• 定义变量 变量名 = 值

• 使用变量 变量名

xxxxxxxxxx
19
1
name = "张三"
2
name = "小明"
3
print(name)
4

5
x = 10
6
print(x)
7
x = 100
8
print(x)
9
x = 1000
10
print(x)
11

12
a = 100
13
a = a + 200
14
print(a)
15

16
name1 = "张三"
17
name2 = "李四"
18
name2 = name1
19
print(name2)

基础类型

int 整型，str字符串，float浮点型， bool布尔型，列表 list，元组 tuple，字典 dict，集合set

xxxxxxxxxx
16
1
# 变量类型
2
# int类型 整型 表示所有的整数
3
num = 10
4
print(type(num))
5

6
# str类型 字符串 表示字符串信息
7
name ="张三"
8
print(type(name))
9

10
# float类型 浮点型 表示所有小数
11
price = 9.9
12
print(type(price))
13

14
# bool类型 布尔型 表示逻辑值 True False
15
correct = False
16
print(type(correct))

得到变量的类型

xxxxxxxxxx
2
1
numType = type(num)
2
print(numType)

赋值运算

xxxxxxxxxx
16
1
x = 0
2
x = x + 1 # 等价于 x+=1
3
print(x)
4

5
y = 0
6
y += 1
7
print(y)
8

9
# -= 
10
z = 10
11
z -= 5
12
print(z)
13

14
a1 = 2
15
a1 = a1 ** 3 #等价于 a1**=3
16
print(a1)

类型转换

常用转换包含 ：

• 转换为字符串str

• 转换为整型 int

• 转换为浮点型 float

xxxxxxxxxx
12
1
# 转换为字符串的函数 str
2
a = 10
3
print(type(a))
4

5
# 转换为整数的函数 int
6
b = str(a)
7
print(type(b))
8

9
# 转换为浮点的函数 float
10
num = 100
11
f_num = float(num)
12
print(type(f_num))

格式化字符串

%格式化字符串

• 单个占位符格式化字符串

  “包含1个占位符的格式化字符串” % 变量

• 多个占位符格式化字符串

  “包含多个占位符的格式化字符串” % (变量1，变量2，…)

占位符包括：

%d整数 %s字符串 %f 浮点型 %.4f 4代表取小数点4位

注：s%可以通用

xxxxxxxxxx
32
1

2
# 单个占位符字符串的信息
3
# “包含1个占位符的格式化字符串” % 变量 
4

5
# 多个占位符字符串的信息
6
# “包含多个占位符的格式化字符串” % (变量1，变量2，…)
7

8
age = 18
9
name = "王大锤"
10

11
# 1个占位符的情况
12

13
# 字符串
14
str1 = "我的名字叫%s" % name
15

16
# 整型 %d %s 都可以，占位符 %s 可以通用
17
str2 = "我的年龄是%d岁" % age
18
str3 = "我的年龄是%s岁" % age
19

20
# 多个占位符的情况
21
str4 = "我的名字叫%s，我的年龄是%s岁" % (name,age)
22

23
address = "周口"
24
num = 3
25
game = "王者荣耀"
26
str5 = "我的家住在%s，我有%s个死党，我喜欢玩%s游戏" % (address,num,game)
27

28

29
# 浮点型 占位符 %f 或 %s    %.2f 保留两位小数
30
price = 9.9
31
print("我买的商品价格为%.1f元" % price)
32
print("我买的商品价格为%s元" % price)

f格式字符串

xxxxxxxxxx
10
1
# f格式化字符串
2
name = "王大锤"
3
age = 28
4
dream = "迎娶白富美，走上人生巅峰"
5
# 我叫xx，今年xx岁，我的梦想是xx
6
print(f"我的名字叫{name}，今年{age}岁，我的梦想是{dream}")
7

8
pi = 3.1415926
9
# .2f表示保留两位小数
10
print(f"结果为{pi:.2f}") # 结果为3.14

input输入

接受键盘上的输入信息，然后赋值给变量

input函数接收的数据默认为字符串类型

xxxxxxxxxx
18
1
# 接受键盘上的输入信息
2
name = input("请输入您的名字")
3
print(name)
4

5
num = input("请你输入一个数")
6
print(num)
7
print(type(num))
8

9
name = input("请输入姓名")
10
age = input("请输入年龄")
11
tel = input("请输入电话")
12

13
# 第一种
14
print("我的名字叫%s,年龄是%s岁,电话是%s"%(name,age,tel))
15

16
age = int(age)
17
tel = int(tel)
18
print("我的名字叫%s,年龄是%d岁,电话是%d"%(name,age,tel))

xxxxxxxxxx
18
1
# 请输入三角形三个边长，求打印出三角形的周长是都多少
2
# 要求分三次输入，输入提示有 “输入第一个边 输入第二个边 输入第三个边”
3
# 输出必须是"三角形的周长是xx"
4
a = input("输入第一个边")
5
b = input("输入第二个边")
6
c = input("输入第三个边")
7
sum = int(a) + int(b) + int(c)
8
print("三角形的周长是%d"%sum)
9

10
# split()默认以空格为分割
11
a,b,c = input("输入三个边").split()
12
sum = int(a) + int(b) + int(c)
13
print("三角形的周长是%d"%sum)
14

15
# 还能自定义分割字符
16
a,b,c = input("输入三个边").split(",")
17
sum = int(a) + int(b) + int(c)
18
print("三角形的周长是%d"%sum)

if语句

定义:

用于描述“如果满足什么条件，就怎么样，否则就怎么样”的语法。

if单语句

xxxxxxxxxx
2
1
# 格式    if 条件判断:
2
#           条件成立执行代码

xxxxxxxxxx
6
1
score = 60  #我的考试得分
2
if score <= 60:
3
    print("被爸爸揍了一顿")
4

5
if score > 90:
6
    print("爸爸奖励我一个苹果笔记本")

if else 语句

xxxxxxxxxx
5
1
# 格式
2
#        if 条件判断:
3
#           条件成立执行代码
4
#        else:
5
#           条件不成立执行的代码

xxxxxxxxxx
5
1
score = int(input("我考试的分数"))
2
 if score < 60:
3
     print("被爸爸揍了一顿")
4
 else:
5
     print("爸爸给我多买个馒头")

if elif ... else 语句

xxxxxxxxxx
10
1
#格式
2
#        if 条件1判断:
3
#           条件1成立执行代码
4
#        elif 条件2判断:
5
#           条件2成立执行代码
6
#        elif 条件3判断:
7
#           条件3成立执行代码
8
#        ....
9
#        else:
10
#           条件都不成立执行的代码

xxxxxxxxxx
14
1
# 根据考试分数，爸爸给与的奖励
2
score = int(input("我考试的分数"))
3
if score < 30:
4
    print("被爸爸揍了三顿")
5
elif score >=30 and score < 50:
6
    print("被爸爸揍了两顿")
7
elif score >=50 and score < 60:
8
    print("被爸爸揍了一顿")
9
elif score >= 60 and score < 80:
10
    print("爸爸给我多买一个馒头")
11
elif score >= 80 and score < 90:
12
    print("爸爸给我多买两个馒头")
13
else:
14
    print("爸爸给我买个烧鸡")

if嵌套

xxxxxxxxxx
21
1
# if嵌套是 if语句中又加了if语句
2
# if层级关系 通过tab键缩进来表示的
3
score = int(input("我考试的分数"))
4
# 爸爸是否比较忙
5
busy = False
6
# 爸爸的钱包的钱
7
money = 10000
8
if score < 60:
9
    if busy:
10
        print("爸爸以后再揍我")
11
    else:
12
        print("被爸爸揍了一顿")
13
elif score >= 70 and score < 90:
14
    print("爸爸给我多买一个馒头")
15
elif score >= 90:
16
    if not busy and money >= 9999:
17
        print("爸爸给我买个苹果笔记本")
18
    else:
19
        print("爸爸给我多买两个馒头")
20
else:
21
    print("爸爸不揍你，也不奖励你")

课堂练习，商品满减

xxxxxxxxxx
24
1
# 京东买商品，价格满1000可以减去100，价格满500减50，价格满300减去20
2
# “输入你要买的价格”，打印出 “商品满减之后的价格是多少”
3

4
# 第一种写法
5
price = int(input("输入你要买的价格"))
6
if price >= 1000:
7
    print("商品满减之后的价格是%d"%(price-100))
8
elif price >=500 and price < 1000:
9
    print("商品满减之后的价格是%d"%(price-50))
10
elif price >=300 and price < 500:
11
    print("商品满减之后的价格是%d"%(price-20))
12
else:
13
    print("商品价格是%d"%price)
14

15
# 第二种写法 判断条件的顺序不能改变
16
price = int(input("输入你要买的价格"))
17
if price >= 1000:
18
    print("商品满减之后的价格是%d"%(price-100))
19
elif price >= 500:
20
    print("商品满减之后的价格是%d"%(price-50))
21
elif price >= 300:
22
    print("商品满减之后的价格是%d"%(price-20))
23
else:
24
    print("商品价格是%d"%price)

循环语句

while 循环

概念

是程序中反复执行的某些代码的过程

作用

重复执行某些代码

基础语法

xxxxxxxxxx
2
1
# while 条件:
2
#    执行的语句

两种写法

xxxxxxxxxx
13
1
# 循环5次的第一种写法 
2
# 循环从0开始 0 1 2 3 4
3
num = 0
4
while num < 5:
5
    print(num)
6
    num = num + 1
7

8
# 循环5次的第二种写法
9
# 循环从1开始 1 2 3 4 5
10
num = 1
11
while num <= 5:
12
    print(num)
13
    num = num + 1

for循环

格式

xxxxxxxxxx
1
1
for n in range(开始值，结束值，步长)

注意：

• n每次循环增加步长，默认步长为1

• n的值包含开始值 不包含结束值

xxxxxxxxxx
11
1
# 循环从0开始 0 1 2 3 4 
2
for n in range(0,5):
3
     print(n)
4
  
5
# 循环从1开始 1 2 3 4 5
6
for n in range(1,6):
7
     print(n)
8

9
# 步长为2    1 3 5
10
for n in range(1,6,2):
11
     print(n)

range

xxxxxxxxxx
2
1
range(0,5) # 相当于生成了0 1 2 3 4 这5个数
2
range(1,6) # 相当于生成了1 2 3 4 5 这5个数

和if组成嵌套

xxxxxxxxxx
5
1
for n in range(1,10):
2
    if n > 5:
3
        print("满足条件的数是 %d"%n)
4
    else:
5
        print("不满足条件的数是 %d"%n)

break

作用

跳出本次循环，终止本次循环的意思

格式

xxxxxxxxxx
7
1
# while 条件:
2
#       if 跳出循环的条件:
3
#           break
4

5
# for n in range(开始值,结束值):
6
#       if 跳出循环的条件
7
#           break

使用

xxxxxxxxxx
9
1
# 跑5圈 n = 1 2 3 4 5
2
for n in range(1,6):
3
    print("跑的圈数%d"%n)
4

5
    if n == 3:
6
        print("我晕倒了，跑不动了")
7
        break
8

9
print("操场跑圈结束")

xxxxxxxxxx
8
1
# 看5次电影 n = 1 2 3 4 5
2
for n in range(1,6):
3
    print("看电影%d次"%n)
4
    if n == 3:
5
        print("实在不想看了")
6
        break
7

8
print("看电影结束")

continue

作用

xxxxxxxxxx
1
1
不执行本次循环中continue后边的代码

格式

xxxxxxxxxx
9
1
# while 条件:
2
#   if 跳过的条件:
3
#       continue
4
# 执行语句(当continue执行后，后边的语句不会再执行)
5

6
# for n in range(开始值,结束值):
7
#   if 跳过的条件:
8
#       continue
9
# 执行语句(当continue执行后，后边的语句不会再执行)

使用

xxxxxxxxxx
6
1
# 看50集电视剧 跳过第10集到16集
2
for n in range(1,51):
3
    if n >= 10 and n <=16:
4
        continue
5
    print("看的集数为%d集"%n)
6

xxxxxxxxxx
5
1
# 用循环打印10(包含10)以内的数，要求3到5用continue跳过
2
for n in range(1,11):
3
    if n >= 3 and n<=5:
4
        continue
5
    print(n)

嵌套循环

语法

xxxxxxxxxx
1
1
循环中又包含了另外一个循环

格式

xxxxxxxxxx
17
1
# 循环中又包含了另外一个循环
2
while 条件:
3
   while 条件:
4
       执行的代码
5

6
for n in range(开始值,结束值)
7
   for m in range(开始值,结束值)
8
       执行的代码
9
        
10
while 条件:
11
    for m in range(开始值,结束值)
12
       执行的代码
13
        
14
for n in range(开始值,结束值)
15
   while 条件:
16
       执行的代码     
17
        

举列

xxxxxxxxxx
26
1
# 王老师让我们上来做题 班上总共有五排 四列的座位，人数已经坐满
2
# 一排开始 1 2 3 4
3
# 二排开始 1 2 3 4
4
# 三排开始 1 2 3 4
5
# 四排开始 1 2 3 4
6
# 五排开始 1 2 3 4
7

8
# #第一排人编号
9
# for n in range(1,5):
10
#     print(n)
11
#
12
# #第二排人编号
13
# for n in range(1,5):
14
#     print(n)
15
#
16
# #第三排人编号
17
# for n in range(1,5):
18
#     print(n)
19
#
20
# #第四排人编号
21
# for n in range(1,5):
22
#     print(n)
23
#
24
# #第五排人编号
25
# for n in range(1,5):
26
#     print(n)

xxxxxxxxxx
3
1
for m in range(1,6):
2
    for n in range(1,5):
3
       print("王老师让第%d排第%d个人上来做题"%(m,n))

使用

xxxxxxxxxx
44
1
# 打印5行5列的*的字符
2

3
*****
4
*****
5
*****
6
*****
7
*****
8

9
for m in range(1,6):
10
     for n in range(1,6):
11
         print("*",end="")
12
     print()
13

14
    
15
#打印以下图形
16

17
*
18
**
19
***
20
****
21
*****
22

23
#发现规律，内循环的次数和当前行数是相等的，
24
#当前为第几行就循环几次
25

26
 for m in range(1,6):
27
     for n in range(1,m+1):
28
         print("*", end="")
29
     print()
30

31

32
#2.输出以下显示
33

34
**
35
***
36
****
37
*****
38
******
39

40
#发现规律每一行的#个数都比当前行数大1的图形
41
 for m in range(1,6):
42
     for n in range(1,m+2):
43
         print("*", end="")
44
     print()

九九乘法表

xxxxxxxxxx
17
1
# 初始打印
2
for m in range(1, 10):
3
    for n in range(1, m + 1):
4
        print("*", end="  ")
5
    print()
6

7
# 框架打印
8
for m in range(1, 10):
9
    for n in range(1, m + 1):
10
        print("1*1=1", end="  ")
11
    print()
12

13
# 最终打印
14
for m in range(1, 10):
15
    for n in range(1, m + 1):
16
        print("%d*%d=%d" % (m, n, m * n), end="  ")
17
    print()

字符串

语法

• 变量名 = "字符串信息"

• 变量名 = ‘字符串信息’

xxxxxxxxxx
2
1
name = "张三"
2
address = "河南省张家村大王路108号"

字符串切片

切片

就是指获取字符串中的某一部分，形成一个新的字符串

切片的格式

• 字符串[开始索引：结束索引]

• 字符串[开始索引：结束索引:步长]

• 注意：开始索引从0开始 结束索引不包含当前索引值

xxxxxxxxxx
18
1
newName = name[1]
2
newAddress = address[3:9]
3
print(newName)
4
print(newAddress)
5
# 求address地址的字符的个数
6
print(len(address))
7
print(len(name))
8

9
# 开始索引从0开始   不包含结束索引
10
address = "河南省周口市川汇区张家村大王路108号"
11
# 要求用 切片格式 字符串[开始索引：结束索引]
12

13
# 打印出 "周口市"
14
print(address[3:6])
15
# 打印出 “张家村”
16
print(address[9:12])
17
# 打印出这句字符的个数
18
print(len(address))

字符串基本操作

in

格式

字符串1 in 字符串2

用法

判断字符是否在另一个字符内 字符串1 in 字符串2

xxxxxxxxxx
8
1
# str1 = "周口市"
2
# str2 = "河南省周口市"
3
# print(str1 in str2)
4

5
# 判断 字符串1 “王老师” 是否在字符串2 “王老师喜欢吃肉”
6
 print(“王老师” in “王老师喜欢吃肉”)
7
# 判断 字符串1 "王者荣耀" 是否在字符串2 "我喜欢玩英雄联盟"
8
 print(“王者荣耀” in “我喜欢玩英雄联盟”)

not in

字符串1 not in 字符串2

xxxxxxxxxx
9
1
# #判断字符是否不在另一个字符内 
2
# str3 = "张1"
3
# str4 = "张三丰"
4
# print(str3 not in str4)
5

6
# 判断 字符串1 “王老师” 是否在字符串2 “王老师喜欢吃肉”
7
 print(“王老师” not in “王老师喜欢吃肉”)
8
# 判断 字符串1 "王者荣耀" 是否在字符串2 "我喜欢玩英雄联盟"
9
 print(“王者荣耀” not in “我喜欢玩英雄联盟”)

len

返回字符串的个数

格式 len("字符串")

xxxxxxxxxx
3
1
name = "我的名字叫王大锤"
2
# 打印出这句字符的个数
3
print(len(name))

字符格式化转换操作

xxxxxxxxxx
5
1
# strip 去掉字符串左右两边的空格 lstrip 去左空格 rstrip去右空格
2
str1 = "   王老师打豆豆   "
3
print(str1.strip())
4
print(str1.lstrip())
5
print(str1.rstrip())

字符串拆分

split (参数)

把当前字符串拆散 拆成 参数左边，参数右边

xxxxxxxxxx
7
1
# 把当前字符串拆散 拆成 参数左边，参数右边
2
strA = "hello python"
3
print(strA.split("o"))  #['hell', ' pyth', 'n']
4

5
# 拆分的参数 “，”，拆成三个字符串
6
strB = "我叫王大锤，今年18岁，喜欢看电影"
7
print(strB.split("，"))  # ['我叫王大锤', '今年18岁', '喜欢看电影']

字符串连接

str1+str2 连接两个字符串

xxxxxxxxxx
17
1
# 连接  str1+str2 连接两个字符串    join(str)填充
2
str1 = "王老师"
3
str2 = "吃饭喝茶打豆豆"
4
str3 = "看电视剧"
5

6
# print(str1 + str2)
7
# print(str1 + str3)
8

9
# join 把str2填充到字符串str1中
10
str1 = "我要吃饭"
11
str2 = "！"
12
print(str2.join(str1))  # 我！要！吃！饭
13

14
# join 把列表listA中的数据取出来，并且以str2连接数据
15
listA = ["刘备","关羽","张飞"]
16
str2 = "！"
17
print(str2.join(listA))     # 刘备！关羽！张飞

字符串查找

• 查找 find("字符串")

• 格式 find("字符串",开始查找位置，结束查找位置)

• 找到了返回第一个匹配字符串的索引，找不到返回 -1

xxxxxxxxxx
2
1
str1 = "吃饭的时候碰见王老师了，王老师吃完回去了"
2
print(str1.find("王老师"))

字符串替换

替换 replace(被替换的字串，新字串，替换数量)

xxxxxxxxxx
2
1
str1 = "王老师吃饭，王老师看电视，王老师打豆豆"
2
print(str1.replace("王老师", "张老师", 3))

列表

概念

是一种有序的，可变的，可存储不同数据类型的结构

列表格式

xxxxxxxxxx
13
1
# 索引       0     1     2
2
# 变量名 = [数据1，数据2，数据3，...]
3

4
# 获取列表数据
5
# 列表名[索引]
6

7
# 可以存储不同的数据类型
8
listA = ["小明","小红",666,9.9,True]
9

10
# 举例
11
# 刘备，关羽，张飞排队打饭
12
#           0     1     2
13
listA = ["刘备","关羽","张飞"]

查询

按索引取出数据

xxxxxxxxxx
4
1
listA = ["刘备","关羽","张飞"]
2
print(listA[0])  # 刘备
3
print(listA[1])  # 关羽
4
print(listA[2])  # 张飞

修改

对查询的结果进行赋值

xxxxxxxxxx
5
1
listA = ["刘备","关羽","张飞"]
2
listA[0] = "刘玄德"
3
listA[1] = "关二爷"
4
listA[2] = "张翼德"
5
print(listA)    # ['刘玄德', '关二爷', '张翼德']

插入

• append

  append末尾添加 append(数据)

• insert

  insert插入 insert(位置，数据)

• extend

  extend末尾添加一个列表 extend(列表)

xxxxxxxxxx
15
1
# append
2
listA = ["刘备","关羽","张飞"]
3
listA.append("貂蝉")
4
print(listA)    # ['刘备', '关羽', '张飞', '貂蝉']
5

6
# insert
7
listA = ["刘备","关羽","张飞"]
8
listA.insert(1,"吕布")
9
print(listA)    # ['刘备', '吕布', '关羽', '张飞']
10

11
# extend
12
listA = ["刘备","关羽","张飞"]
13
listB = ["大乔","小乔"]
14
listA.extend(listB)
15
print(listA)    # ['刘备', '关羽', '张飞', '大乔', '小乔']

删除

• remove(数据)

  删除数据相等的第一个列表中的数据

• pop(索引)

删除当前索引的数据

xxxxxxxxxx
9
1
listA = ["刘备","关羽","张飞"]
2
listA.remove("关羽")
3
print(listA)    # ['刘备', '张飞']
4

5
#          0      1     2
6
listA = ["刘备","关羽","张飞"]
7
listA.pop(2)
8
print(listA)    # ['刘备', '关羽']
9

求下标索引

xxxxxxxxxx
3
1
# 求下标索引 index(数据)
2
listA = ["刘备","关羽","张飞"]
3
print(listA.index("关羽"))    # 1

出现数据的个数

xxxxxxxxxx
2
1
listA = ["王老师","豆豆","张老师","豆豆","小明"]
2
print(listA.count("豆豆"))    # 2

清空列表

xxxxxxxxxx
6
1
# 清空列表中的数据 clear  列表名 = []
2
# 清空listA
3
listA = ["王老师","豆豆","张老师","豆豆","小明"]
4
listA.clear()
5
# listA = []
6
print(listA)    # []

列表遍历

xxxxxxxxxx
5
1
listA = ["王老师","豆豆","张老师","豆豆","小明"]
2

3
# 列表遍历 for 数据 in 列表名
4
 for n in listA:
5
     print(n)

排序

xxxxxxxxxx
9
1
listA = [10,5,3,2,8]
2
# 排序sort 从小到大排序  sort(reverse = True)从大到小排序
3
listA.sort()
4
print(listA)    # [2, 3, 5, 8, 10]
5

6
# 用sort函数进行排序 如果是字符或者字符串则按字符编码值进行排序
7
listB = ["d","c","A","aa","ab","a"]
8
listB.sort()
9
print(listB)    # ['A', 'a', 'aa', 'ab', 'c', 'd']

字典

定义

字典是一种使用“键值对结构”存储数据的存储模型。

xxxxxxxxxx
2
1
# 字典格式
2
#   变量名 = {键1:值1 , 键2:值2, ...}

字典的创建

xxxxxxxxxx
4
1
# 创建空字典
2
dictA = {}
3
# 创建有数据的字典
4
dictB = {"name":"王老师", "height":165, "weight":90, "hobby":"打豆豆"}