Python基础 1h速成

Python

1 数据类型

1.1 数值型

1.2 布尔类型

1.3 列表

1.4 元组

1.5 字符串

1.6 字典

2 流程控制语句

2.1 赋值语句

2.2 if语句（分支语句）

2.3 while循环

2.4 for循环

2.5 函数

Python

1 数据类型

1.1 数值型

支持大数存储和运算（Python3）

能够表示的数值种类

十进制整数：100，0，123，-100

八进制整数：0o17 （对应十进制15）

十六进制整数：

0x13（对应十进制19）

0x1F（对应十进制31）

0x2b（对应十进制43）

浮点数（小数）：3.14，1.125

支持的数值运算

+加，-减，*乘，/除

//整除，%取余（取模），**次幂指数运算

()优先级运算符，提升运算优先级

a = 100

print(a) # 100

a = 3.14

print(a) # 3.14

# a = 15

a = 0o17

print(a) # 15

a = 0x2b

print(a) # 43

a = 10

b = 3

print(a + b) # 13

print(a - b) # 7

print(a * b) # 30

print(a / b) # 3.333333…

print(a // b) # 3

print(a % b) # 1

print(a ** b) # 1000

a = -10

b = 3

print(a // b) # -4

print(a % b) # 2

# C语言中 整除结果为 -3

取模结果为 -1

# 不一致的原因在于Python取整是向负无穷取整

#

而C语言是向0取整

随机数

import random

# 随机产生一个[1,1000]之间的数

a = random.randint(1, 1000)

print(a)

# 2023015656

# 2023015755

a = random.randint(0, 99)

a = a + 2023015656

print(a)

a = random.randint(2023015656, 2023015755)

print(a)

# 随机产生一个[10,20]之间的小数

a = random.uniform(10, 20)

print(a)

1.2 布尔类型

布尔类型变量的值只有两种：True，False

逻辑运算：and与，or或，not非

关系运算：>，<，>=，<=，==，!=

print(10 > 9) # True

print(10 <= 9) # False

a = 5

print(a > 1 and a < 10) # True

print(1 < a < 10)

# 效果与上一行相同，紧存在于Python

b = 6

print(b < 1 or b > 10)

# False

print(not (1 <= b <= 10)) # False

c = 7

print(c % 2 == 0) # c是否为偶数

1.3 列表

序列：有顺序编号的结构 称之为 序列

列表

元组

字符串

序列的索引：（其它编程语言中通常叫做下标）

序列中所有元素都是有索引的

索引可以是正的，表示从左到右，从前到后，是正向方向。是从0开始依次递增的。如果序列

中有N个元素，合法的索引范围是0~N-1。

索引也可以是负的，表示从右到左，从后到前，是反向方向。从最后一个元素-1开始，往前

依次递减，从后往前合法的索引范围是-1~-N。

列表是序列的一种。

列表的声明定义形式：

L = []# L列表是一个空列表

L = [1, 2, 3, 4]# L列表共有4个元素，依次为1,2,3,4

列表中的元素是用逗号,隔开的

L = [1, 2, 3, 4]

print(L)

# [1, 2, 3, 4]

print(L[0])

print(L[1])

print(L[2])

print(L[3])

# print(L[4])

print(L[-4])

print(L[-3])

print(L[-2])

print(L[-1])

# 1

# 2

# 3

# 4

# IndexError: list index out of range

# 1

# 2

# 3

# 4

L1 = []

print(L1)

# []

L2 = [11, 22, 33]

print(L2[1])

L2[1] = 222

print(L2[1])

print(L2)

# 22

# 222

# [11, 222, 33]

列表中的元素类型可以不一致

L = [100, 3.14, True, “Hello”, [1, 2, 3]]

print(L[0])

print(L[1])

print(L[2])

print(L[3])

print(L[4])

# 100

# 3.14

# True

# Hello

# [1, 2, 3]

print(L[4][1]) # 2

序列的分片操作

序列名[start : stop : step]

start：开始位置

stop：结束位置，待截取的最后一个元素为结束为止之前的一个元素

step：步长，如果省略，默认步长为1

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(L[0:5:1])

print(L[0:5:2])

# [1, 2, 3, 4, 5]

# [1, 3, 5]

print(L[0:5])

# [1, 2, 3, 4, 5]

print(L[2:8])

print(L[2:])

print(L[:8])

print(L[:])

# [3, 4, 5, 6, 7, 8]

# [3, 4, 5, 6, 7, 8, 9, 10]

# [1, 2, 3, 4, 5, 6, 7, 8]

# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

L = [1, 2, 3, 4, 5, 6]

print(L[0:3])

# [1, 2, 3]

print(L[-6:-3])

# [1, 2, 3]

print(L[2::-1])

print(L[-4::-1])

# [3, 2, 1]

# [3, 2, 1]

print(L[-1::-2])

# [6, 4, 2]

L1 = [1, 2, 3, 4, 5, 6]

L2 = L1

# 给L1列表起了另外一个名字L2

L2[1] = 222

print(L2)

print(L1)

# [1, 222, 3, 4, 5, 6]

# [1, 222, 3, 4, 5, 6]

L1 = [1, 2, 3, 4, 5, 6]

L2 = L1[:] # 将L1拷贝了一份，然后起名L2

L2[1] = 22

print(L2)

print(L1)

# [1, 22, 3, 4, 5, 6]

# [1, 2, 3, 4, 5, 6]

序列的一些通用操作

序列 + 序列：拼接两个序列

序列 * 正整数：

L1 = [1, 2, 3]

L2 = [4, 5, 6]

L3 = L1 + L2

print(L3) # [1, 2, 3, 4, 5, 6]

L4 = L1 * 4

print(L4) # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

列表的一些常用操作

L1 = [1, 2, 3, 4]

L1.append(5) # 在列表L1的末尾添加新元素5

print(L1)

# L2 = L1[:]

L2 = L1.copy() # 将L1拷贝一份起名L2

L2[0] = 111

print(L2) # [111, 2, 3, 4, 5]

print(L1) # [1, 2, 3, 4, 5]

L1 = [1, 2, 5, 6]

L1.insert(2, 3) # 将3插入到L1的索引2位置

L1.insert(3, 4) # 将4插入到L1的索引3位置

print(L1) # [1, 2, 3, 4, 5, 6]

L1.insert(3, 4)

print(L1) # [1, 2, 3, 4, 4, 5, 6]

L1.pop(3) # 将L1中索引为3的元素弹出

print(L1)

L1 = [1, 2, 3, 4, 2]

L1.remove(2) # 删除L1中第一个出现的2元素

print(L1) # [1, 3, 4, 2]

L1 = [1, 2, 3, 4]

L1.reverse() # 将L1自身整体逆置

print(L1) # [4, 3, 2, 1]

L1.clear() # 将L1清空

print(L1) # []

L1 = [1, 2, 3]

L2 = [4, 5, 6]

L1.extend(L2) # 将L2列表添加的L1的末尾

# L1 = L1 + L2

print(L1) # [1, 2, 3, 4, 5, 6]

L1 = [1, 2, 3, 2, 3, 2, 3, 2, 2, 2, 2]

print(L1.count(2)) # 7

L1列表中元素2的数量

Python中的一些通用方法

len()：求序列元素个数

max()：求序列中的最大元素

min()：求序列中的最小元素

L = [4, 1, 3, 2, 6, 7, 5]

print(len(L)) # 7

print(max(L)) # 7

print(min(L)) # 1

1.4 元组

元组：不能修改的列表

L = (1, 2, 3, 4)

print(L[2])

L[2] = 33

print(L)

# ‘tuple’ object does not support item assignment

1.5 字符串

字符串：字符组成的串

字符串的表示形式

双引号形式：“hello”

单引号形式：‘hello’

print(“Hello”)

# Hello

print(‘Hello’)

print(“‘Hello’”)

print(‘“Hello”’)

# 转义字符

# Hello

# ‘Hello’

# “Hello”

print(“'Hello”“) # 'Hello”

print(“He\tllo”)

print(“He\nllo”)

print(“He\rllo”)

print(“hi\t”)

# 制表符

# 换行符

# 回车符

# \

Python中如何读取的输入数据：input()

input()：可以在命令行窗口中获取用户输入的数据

int()：可以将字符串转换成整型

float()：可以将字符串转换成浮点数类型

str()：将数值类型转换为字符串

s = input()

print(s)

# 从命令行读取一行数据赋值到s

a = input()

b = input()

print(a+b)

# 读取到字符串 “zhangsan”

# 读取到字符串 “lisi”

# “zhangsanlisi”

a = input()

b = input()

print(int(a)+int(b))

a = int(input())

b = int(input())

print(a+b)

Python中如何输出数据：print()

print()：可以将数据输出到命令行

print()函数会在输出时自动在末尾输出一个换行符

print()格式化输出

print(“格式化字符串” % (要输出的变量列表))

%s：将填入数据作为字符串输出

%d：将填入数据作为整数输出

%f：将填入数据作为浮点数输出

如果不确定该用什么，那就用%s

print(“Hello”)

print(“Hello”, end=‘\n’)

print(“----------------”)

print(“Hello”, end=‘’)

print(“Hello”)

print(“----------------”)

print(“ZhangSan”, end=‘,’)

print(“LiSi”, end=‘,’)

print(“WangWu”)

print(“好久不见，%s，其实我是%s!” % (“张三”, “蔡徐坤”))

print(“好久不见，%s，其实我是%s!” % (“李大爷”, “邓丽君”))

print(“我猜你今年%d岁” % (18))

print(“我猜你今年%s岁” % (18))

字符串常用方法

s = “abcd1234hahaha”

print(s.find(“1234”)) # 4 在s中查找"1234"子串出现的位置

print(s.find(“abcd”)) # 0

print(s.find(“ha”))

# 8

print(s.find(“nihao”)) # -1 未找到返回-1

s = “abaacaadaaa”

s = s.strip(“a”)

# 去掉s中首尾出现的"a"

print(s) # baacaad

s = input(“请输入你的姓名：”) # "

s = s.strip(" ")

吴彦祖

"

print(s + “你好”)

s = “ZhangSan”

s = s.upper() # 将s字符串中所有小写字母转换为大写

print(s)

s = s.lower() # 将s字符串中所有大写字母转换为小写

print(s)

s = “ZhangSan”

s = s.swapcase()

print(s)

# 将s字符串中字母大小写转换

s = “作者：张三”

s = s.replace(“张三”, “李四”) # 将s中的"张三"替换为"李四"

print(s)

s = “1,2,3,4,5,6,7”

L = s.split(“,”)

# 将s根据","分割成一个列表

print(L) # [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’]

L = [“1”, “2”, “3”, “4”, “5”, “6”, “7”]

s = “,”.join(L) # 将列表L中的元素通过","拼接起来

print(s)

# 1,2,3,4,5,6,7

# 请输入加法表达式：1+2

# 1+2的和为：3

s = input(“请输入加法表达式：”)

L = s.split(“+”)

print(“%s的和为：%d” % (s, int(L[0])+int(L[1])))

1.6 字典

存储键-值对的数据容器

m = {“2023015667”: 25, “2023015668”: 10, “2023015665”: 2}

print(m[“2023015668”])

print(m[“2023015667”])

# 如果键存在，则修改其值

m[“2023015665”] = 40

print(m[“2023015665”])

# 如果键不存在，则添加新的记录

m[“2023015622”] = 18

print(m)

2 流程控制语句

2.1 赋值语句

=：将=右侧表达式的值赋值给左侧的变量，=称之为赋值运算符

a = 10

b = 20

a, b = 10, 20

print(a)

print(b)

# 10

# 20

# t = a

# a = b

# b = t

a, b = b, a

print(a)

print(b)

# 20

# 10

2.2 if语句（分支语句）

一般形式

if <条件1>:

<语句块1>

elif <条件2>:

<语句块2>

elif <条件3>:

<语句块3>

…

else:

<语句块n>

实际开发中，可以根据实际情况来编写if语句，其中if分支写1个，elif可以写任意多个（

），else分支可以写0或1个。

num = int(input(“请输入一个正整数:”))

if num % 2 == 0:

print(“偶数”)

else:

print(“奇数”)

# 输入1~7中的一个数字，输出 星期一、星期二、…、星期日

# num = int(input(“请输入1~7之间的一个整数：”))

# if num == 1:

#

print(“星期一”)

# elif num == 2:

#

print(“星期二”)

# elif num == 3:

#

print(“星期三”)

# elif num == 4:

#

print(“星期四”)

# elif num == 5:

#

print(“星期五”)

# elif num == 6:

#

print(“星期六”)

# else:

#

print(“星期日”)

m = {1: “星期一”, 2: “星期二”, 3: “星期三”, 4: “星期四”, 5: “星期五”, 6: “星期六”, 7: "星期

日"}

num = int(input(“请输入1~7之间的一个整数：”))

print(m[num])

# 输入一个0~100整数分数，输出对应评级

# [0, 59]

# [60, 69]

# [70, 89]

差

中

良

# [90, 100] 优

# 其它分值

提示非法输入

# num = int(input(“请输入您的分数：”))

# if num >= 0 and num < 60:

#

print(“差”)

# elif num >= 60 and num < 70:

print(“中”)

# elif num>= 70 and num < 90:

print(“良”)

# elif num >=90 and num <=100:

print(“优”)

# else:

#

#

#

#

print(“您的输入非法！”)

# num = int(input(“请输入您的分数：”))

# if 0 <= num < 60:

#

print(“差”)

# elif 60 <= num < 70:

print(“中”)

# elif 70 <= num < 90:

print(“良”)

# elif 90 <= num <= 100:

print(“优”)

# else:

#

#

#

#

print(“您的输入非法！”)

num = int(input(“请输入您的分数：”))

if num < 0 or num > 100:

print(“您的输入非法！”)

elif num < 60:

print(“差”)

elif num < 70:

print(“中”)

elif num < 90:

print(“良”)

else:

print(“优”)

# 输入一个年份，判断是否为闰年

# 2023 平年

# 2020 闰年

# 2000 闰年

# 1900 平年

y = int(input(“请输入年份：”))

if y % 100 != 0 and y % 4 == 0:

print(“普通闰年”)

elif y % 400 == 0:

print(“世纪闰年”)

else:

print(“平年”)

if y % 100 == 0:

if y % 400 == 0:

print(“世纪闰年”)

else:

print(“平年”)

else:

if y % 4 == 0:

print(“普通闰年”)

else:

print(“平年”)

2.3 while循环

while语句为循环语句

一般形式：

while <条件>:

<循环语句块>

当<条件>成立时，则执行<循环语句块>，执行完成后继续判断<条件>。

# 打印1~100

num = 1

while num <= 100:

print(num)

num = num + 1

# 打印1~100之间所有的偶数

# num = 1

# while num <= 100:

#

#

#

if num % 2 == 0:

print(num)

num = num + 1

num = 2

while num <= 100:

print(num)

num = num + 2

continue：立即停止本次循环，跳转到循环的<条件>处，执行下一次循环

# 打印1~100之间所有的偶数

num = 1

while num <= 100:

if num % 2 == 1:

num = num + 1

continue

print(num)

num = num + 1

break：直接结束循环，执行循环之后的代码

# 打印1~100之间所有的偶数

num = 1

while True:

if num % 2 == 0:

print(num)

num = num + 1

if num > 100:

break

# 水仙花数

# 一个三位数，每一位上的数字的立方之和等于这个数本身

# 153 = 1*1*1+5*5*5+3*3*3

# num = 100

# while num < 1000:

#

#

#

#

#

#

a = num // 100

b = num // 10 % 10

c = num % 10

if num == a ** 3 + b ** 3 + c ** 3:

print(num)

num = num + 1

a = 1

while a < 10:

b = 0

while b < 10:

c = 0

while c < 10:

num = a * 100 + b * 10 + c

if a**3 + b**3 + c**3 == num:

print(num)

c = c + 1

b = b + 1

a = a + 1

# 给定a和b两个正整数，求他们的最小公倍数

# s = input(“请输入a和b，用,隔开：”)

# L = s.split(“,”)

# a = int(L[0])

# b = int(L[1])

a, b = map(int, input(“输入a和b用,隔开：”).split(“,”))

c = max(a, b)

while True:

if c % a == 0 and c % b == 0:

print©

break

c = c + 1

# 给定a和b两个正整数，求他们的最大公约数

a, b = map(int, input(“输入a和b用,隔开：”).split(“,”))

c = min(a, b)

while True:

if a % c == 0 and b % c == 0:

print©

break

c = c - 1

2.4 for循环

for循环通常是在确定循环次数的情况下使用

while循环通常是在不确定循环次数的情况下使用

一般形式:

for 循环变量 in 迭代器对象:

<循环代码块>

L = [11, 22, 33, 44, 55, 66]

for num in L:

print(num)

s = “HelloWorld!”

for c in s:

print©

range()函数

range()函数可以产生一个迭代器对象

range(start, stop, step)

for i in range(1, 101): # range(1, 101, 1):

print(i)

for num in range(100, 1000):

a = num // 100

b = num // 10 % 10

c = num % 10

if num == a**3 + b**3 + c**3:

print(num)

# 九九乘法口诀表

# 输入n，输出nn乘法口诀表

n = int(input())

for i in range(1, n + 1):

for j in range(1, i + 1):

print(“%d*%d=%d” % (j, i, j * i), end=“\t”)

print(“”)

# n = 5

# for i in range(1, n+1):

#

for j in range(1, 2i-1+1):

#

i

1

2

3

4

5

* 2i-1

- n-i

# ----*

# —***

# --*****

# -*******

# *********

1

3

5

7

9

4

3

2

1

0

# n = 3

# *

# ***

# *****

n = int(input())

for i in range(1, n+1):

for j in range(0, n-i):

print(" “, end=”")

for j in range(0, 2 * i - 1):

print(“*”, end=“”)

print(“”)

# n = 9

#

i

1

2

3

4

5

* 2i-1

- n-i

# ----*

# —***

# --*****

# -*******

# *********

1

3

5

7

9

4

3

2

1

0

# n = 4

#

2*(n-i)+1

i

1

2

3

4

*

7

5

3

1

-

1

2

3

4

# -*******

# --*****

# —***

# ----*

n = int(input())

m = n // 2

n = n - m

for i in range(1, n+1):

for j in range(0, n-i):

print(" “, end=”")

for j in range(0, 2 * i - 1):

print(“*”, end=“”)

print(“”)

for i in range(1, m+1):

for j in range(0, i):

print(" “, end=”")

for j in range(0, 2*(m-i)+1):

print(“*”, end=“”)

print(“”)

# 冒泡排序

# 6 3 7 2 5

n=5

# for i in range(0, n-1):

#

i

0

1

2

3

j n-i-1

# 3 6 2 5|7

# 3 2 5|6 7

# 2 3|5 6 7

# 2|3 5 6 7

4

3

2

1

L = [6, 3, 7, 2, 5]

n = len(L)

for i in range(0, n - 1):

for j in range(0, n - i - 1):

if L[j] > L[j+1]:

L[j], L[j+1] = L[j+1], L[j]

print(L)

# 猜数字小游戏

# 程序随机从1~100之间选一个整数，让玩家来猜

# 每一次，玩家提交自己猜测的数字，程序根据玩家猜测的数字

# 给出提示： 你猜大了，你猜小了，你猜对了

import random

computer = random.randint(1, 100)

flag = True

for i in range(0, 7):

user = int(input(“请输入您猜测的数字：”))

if computer > user:

print(“您猜小了！”)

elif computer < user:

print(“您猜大了！”)

else:

print(“真厉害，您猜对了！”)

flag = False

break

if flag:

print(“你多多少少有点子笨！”)

2.5 函数

一般形式：

def <函数名> (<参数列表>):

<函数体代码块>

<函数名>：函数的名称，用来标识一个函数，通过函数名来完成函数的调用

<参数列表>：函数想要执行，所需的参数。

在调用函数时，要根据<参数列表>传入对应的参数。

<参数列表>中的参数可以直接在<函数体代码块>中直接使用。

<参数列表>可以为空，表示函数的执行不需要参数。

<函数体代码块>：函数具体执行的代码，完成函数对应功能。

return语句：当函数需要返回数据时，可以通过return来实现。另外，return还有表示跳出函数

执行的作用。

def list_sort(L):

n = len(L)

for i in range(0, n):

for j in range(0, n - i - 1):

if L[j] > L[j + 1]:

L[j], L[j + 1] = L[j + 1], L[j]

L1 = [1, 4, 3, 6, 2, 7, 5]

list_sort(L1)

print(L1)

L2 = [22, 11, 33, 66, 44, 55]

list_sort(L2)

print(L2)

def my_sum(a, b):

c = a + b

return c

print(my_sum(1, 2))

print(my_sum(11, 21))

def fun1():

print(“fun1() start”)

fun2()

print(“fun1() end”)

def fun2():

print(“fun2() start”)

fun3()

print(“fun2() end”)

def fun3():

print(“fun3() start”)

print(“fun3() end”)

fun1()

# 现在有一个长列表，列表中保存着n个正整数 （n>2）

# 这个列表中存储的是n个评委对于某项活动的打分

# 需要去掉最大值、最小值之后，返回一个平均值（取整）

def list_sort(L):

n = len(L)

for i in range(0, n):

for j in range(0, n - i - 1):

if L[j] > L[j + 1]:

L[j], L[j + 1] = L[j + 1], L[j]

def fun(L):

list_sort(L)

s = 0

for i in range(1, len(L)-1):

s = s + L[i]

return s // (len(L)-2)

# def fun(L):

#

return (sum(L) - max(L) - min(L)) // (len(L) - 2)

L1 = [99, 100, 80, 81, 90]

print(fun(L1))

# 斐波那契数列

# 1 1 2 3 5 8 13 21 34 55 89 …

# 递归

# 函数直接、或者间接调用函数自身，称之为递归

# f(n) ： 返回第n项斐波那契数

# f(n) = 1

(n1 or n2)

(n>2)

# f(n) = f(n-1) + f(n-2)

# 递归函数：

#

#

1. 确定递归边界

2. 确定递归公式

# L = [0]*10000

#

#

# def f(n):

#

#

#

#

#

#

if n == 1 or n == 2:

return 1

return f(n - 1) + f(n - 2)

# print(f(5))

L = [0]*1000

def f(n):

if n == 1 or n == 2:

return 1

if L[n] == 0:

L[n] = f(n - 1) + f(n - 2)

return L[n]

print(f(500))

# print(f(45))

# 递推

def f(n):

L = [0, 1, 1]

for i in range(3, n+1):

L.append(L[i-1] + L[i-2])

return L[n]

print(f(500))

# 蛇形填数

# 给定一个n*m的矩阵，然后从1开始，填入整数

# 例如 n = 4, m = 5

# 1 2 3 4 5

# 10 9 8 7 6

# 11 12 13 14 15

# 20 19 18 17 16

0

1

2

3

n, m = map(int, input().split())

for i in range(0, n):

for j in range(1, m + 1):

if i % 2 == 0:

o = i * m + j

print(o, end=“\t”)

else:

o = (i + 1) * m - j + 1

print(o, end=“\t”)

print(“”)

# 蛇形填数

# 给定一个n*m的矩阵，然后从1开始，填入整数

# 例如 n = 4, m = 5

# 1 2 3 4 5

# 10 9 8 7 6

# 11 12 13 14 15

# 20 19 18 17 16

0

1

2

3

n, m = map(int, input().split())

for i in range(0, n):

if i % 2 == 0:

for j in range(1, m+1):

print(“%d” % (i * m + j), end=“\t”)

else:

for j in range(m, 0, -1):

print(“%d” % (i * m + j), end=“\t”)

print(“”)

# 选择排序

L = [3, 7, 2, 6, 1, 5]

n = len(L)

for i in range(0, n-1):

m = 0

for j in range(1, n-i):

if L[m] < L[j]:

m = j

L[m], L[n-i-1] = L[n-i-1], L[m]

print(L)

# 汉诺塔问题

# 三根铜柱，编号依次为 A B C

# 现在A上面有n个盘子，问整体移动到C的步骤是怎样的

def hin(n, a, b, c):

if n == 1:

print(“%s -> %s” % (a, b))

return

hin(n-1, a, c, b)

print(“%s -> %s” % (a, b))

hin(n-1, c, b, a)

hin(3, “A”, “C”, “B”)