Python编程从入门到实践（第二版）_前四章

Posted 2023-03-27 张贺贺

目录

• Python编程从入门到实践（第二版）_前四章
• 二、起步
  • 字符串
  • 数
• 三、列表
  • 访问列表元素3.1
    • 访问列表元素
    • 索引是从零开始
    • 使用列表中的各个值
  • 修改添加删除元素3.2
    • 修改
    • 添加append
    • 插入insert
    • 删除元素
    • 组织列表
• 四、操作列表
  • 遍历
  • 创建数值列表
  • 使用列表的一部分：切片
  • 元组

Python编程从入门到实践（第二版）_前四章

@xiaolai\'s works

菜鸟教程 - 学的不仅是技术，更是梦想！

廖雪峰的官方网站

两条路在树林里分岔,我选择走人少的那一条

我认为这本书考验的更多的还是一个人的耐心，很多人都半途而废了

优点：

• 老师讲课的水平比较高，知识点虽然浅显，但是层层递进，前后逻辑连贯严谨，阐述一针见血！
• 课程安排非常好，前期所有的知识点都是为了完成后期的项目，将项目当中的用的到知识点分布在前面几章
• 前期的代码简单，解释详细，学起来势如破竹！成就感满满，作者是懂学生的

看书学比起看视频，我认为是更简单的

二、起步

变量是可以赋给值的标签

字符串

# 加上引号才被识别成为字符串
print(hello)
print("hello")
print(\'hello\')

# 不加引号是被识别成为变量
zs = \'zhangsan\'
print(zs)

# 常见的print关于字符串的方法
print(\'hello\'.title())
print(\'hello\'.upper())
print(\'hello\'.lower())

# f字符串是在python3.6之后引入的
# 在字符串当中使用变量
h = \'hello\'
print(h)
## f\'\'
print(f\'h world\')
print(f\'h.upper world\')

# 在变量赋值的时候使用字符串格式化
first_name = \'zhang\'
last_name = \'san\'
full_name = f\'first_name_last_name\'
message = f\'my name is full_name\'
print(message)

# 使用转义字符
# \\t\\n
print("python1")
print("\\tpython2")
print("my\\tname\'s:\\n\\t\\t\\tzhangsan")

# 在linux当中也大致类似
zh@DESKTOP-RAG9L0F:~$ echo "zhangsan"
zhangsan
zh@DESKTOP-RAG9L0F:~$ echo "zhang\\tsan"
zhang\\tsan
zh@DESKTOP-RAG9L0F:~$ echo -e "zhang\\tsan"
zhang   san
zh@DESKTOP-RAG9L0F:~$ echo -e "zhang\\nsan"
zhang
san

# 使用rstrip()方法删除尾部多余的所有空格，只能删除尾部的哟
# lstrip()删除开头的所有空格
# strip()删除两头的所有空格
zs = \'zhangsan\'
name = \'zhangsan \'
if zs == name:
    print("OK!")
else:
    print("Bad!")
---
zs = \'zhangsan\'
name = \'zhangsan \'
name = name.rstrip()
if zs == name:
    print("OK!")
else:
    print("Bad!")
---

数

# 加减乘除
a = 2
b = 3
c = a + b
print(a + b)
print(a * b /2 -2)
print(c)

# 小数，我们暂时先不控制最终输出的位数
a = 2.2
b = 3.3
print(a + b)

# 基因强大的浮点数，任何数与小数做运算，结果都是小数
a = 2.2
b = 2
print(a + b)
print(a / b)
print(a * b)

# 在数当中，下划线会被认为是方便人类识别的，python会忽略
a = 20_00
b = 2
print(a + b)
print(a / b)
print(a * b)

2002
1000.0
4000

# 同时给多个变量赋值
a,b,c = 1,2,3
print(a,b,c)

# 注意与下面这个做区分
a = b = c = 1
print(a,b,c)

# 常量，在程序的生命周期内保存不变，就是将变量名大写
NAME = 12345

注释与python之禅略过

三、列表

列表的作用：让你一个地方存储成组的信息，可以有几个，也可以有百万个元素，是新手能操作的最强大的python功能之一。

列表是什么：由一系列按照顺序排列的元素组成的列表，由方括号表示。

name = ["zhangsan",\'lisi\',\'wanger\']
print(name)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'zhangsan\', \'lisi\', \'wanger\']

你会发现最终的输出也是由中括号表示的，这种信息看起来像是没处理完的，所以我们需要知道如何访问列表中的

访问列表元素3.1

访问列表元素

# **列表是有序的集合，你想访问哪个元素，仅需要将对应列表的索引告诉pyhton即可
# 变量与索引之间没有点儿，在变量后加点的往往是某种方法，比如print(name.upper())
# 返回值直接就是该元素，没有中括号 ，没有各种引号，简单优雅，这样的数值才是用户希望看到的！
name = ["zhangsan",\'lisi\',\'wanger\']
print(name[0])
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
zhangsan

# 在列表的元素后面直接调用某一种字符串方法也是可以的，但不能在打印整个列表时后面加upper这种方法
# 比如 ，print(name.upper()) 这样会报请求错误
name = ["zhangsan",\'lisi\',\'wanger\']
print(name[0].upper())
print(name[0].upper(),name[1].title())**

索引是从零开始

1. python当中，索引的和一个元素为0，而不是1，大多数编程语言都是这么规定的
2. 如果一个索引特别长，不仅能从前向后数，也可以从后向前数

# 不仅能从前向后数，也可以从后向前数
name = ["zhangsan",\'lisi\',\'wanger\']
print(name[0],name[1],name[2])
print(name[-1],name[-2],name[-3])

使用列表中的各个值

# 像使用变量一样使用列表中的值
name = ["zhangsan",\'lisi\',\'wanger\']
print(f\'my name is name[0]\')

"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
my name is zhangsan

修改添加删除元素3.2

• 列表是随着程序不断发生变化的。应用场景，假如你做一款射杀外星人的游戏时，当某个外星人被杀害时，你就可以将共从列表当中删除，而当出现新的外星人时，你应该把外星人重新添加到列表当中去。
• 永久性的方法都不能赋值给变量，临时性的方法就可以。

修改

# 修改的时候直接用列表的名字加上索引即可，如下所示：
name = ["zhangsan",\'lisi\',\'wanger\']
name[0],name[1] = \'hehua\',\'heye\'
print(name)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'hehua\', \'heye\', \'wanger\']

添加append

**# 追加
# 初始列表是可以为空的哟！然后通过append方法不断的向里面追加
# 有的方法不需要向里面的传值，比如说upper，但是像append这种方法是需要向里面传值的**
name = []
name.append(\'fubao\')
name.append(\'xiangxiang\')
print(name)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'fubao\', \'xiangxiang\']

上述这种列表的使用方式非常常见，因为有时候你并不知道用户要向里面输入什么，所以初始列表是空的，随着程序的运行和用户的输入不断的进行变化。

插入insert

**# 在任意位置插入，甚至可以直接append**
name = [\'hehua\']
name.insert(0,\'xiangxiang\')
name.insert(2,\'fubao\')
print(name)
**"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'xiangxiang\', \'hehua\', \'fubao\']**

删除元素

**# del的方法非常的简单粗暴，同样的，可以删除任何一个元素，彻底删除
# 彻底删除的意思后续的程序都不能再使用这个元素了**
name = [\'hehua\',\'heye\']
del name[1]
print(name)

那我想实现一个这样的效果，就是当我删除了一个值之后，我还要在后面的程序弹出它，比如刚杀掉一个外星人，那我需要将其从列表当中删除，在删除之后，我还想获取刚才被杀掉的这个外星人的坐标，以便在合适的地方显示爆炸效果，那就得用pop方法了，而不能用del方法。

• 默认弹出的顶栈，即从后面向前数

# 正常情况下，我们使用del，返回值还是一个列表
supper_start = [\'heye\',\'hehua\']
del supper_start[0]
print(supper_start,type(supper_start))
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'hehua\'] <class \'list\'>

# 把荷叶从顶流女明星里面弹出，从后向前弹出
supper_start = [\'hehua\',\'heye\']
supper_start.pop()  # 把heye弹出
print(supper_start)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'hehua\']

# 把荷叶从顶流女明星里面弹出之后，我们在程序之后还要获取到底都弹出了哪些小熊
supper_start = [\'hehua\',\'heye\']
pop_panda = supper_start.pop()  # 把被弹出的小熊赋值给pop_panda的变量
print(supper_start)             # 打印超级明星列表里面还有谁
print(pop_panda)                # 打印被弹出的小熊，即pop_panda
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'hehua\']
heye

# 简单的应用
supper_start = [\'hehua\',\'heye\']
pop_panda = supper_start.pop()
print(f\'pop_panda.title() very cute!\')
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
Heye very cute!

**# 弹出任意位置的元素
# 因heye老是给hehua抢吃的，所以把heye弹出，在pop后面指定元素的索引即可**
supper_start = [\'hehua\',\'heye\',\'fubao\']
pop_panda = supper_start.pop(1)
print(f\'pop_panda.title() very cute!\')
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
Heye very cute!

**# 如果列表元素太多，你不想数索引，只记录元素内容，也是可以删除的**
supper_start = [\'hehua\',\'heye\',\'fubao\',\'xiangxiang\']
supper_start.remove(\'fubao\')
print(supper_start)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'hehua\', \'heye\', \'xiangxiang\']

# 被删除的内容可以被定义成变量，后续再使用
supper_start = [\'hehua\',\'heye\',\'fubao\',\'xiangxiang\']
hanguo_panda = \'fubao\'
supper_start.remove(hanguo_panda)
print(supper_start)
print(f\'hanguo_panda delete!\')

remove只删除找到的第一个数值，如果想删除多个，得配合循环，后续进行介绍

组织列表

# 通过sort方法永久性排序，排序完就无法还原了，可以正着排序，也可以反着排序
name = [\'c\',\'a\',\'e\']
name.sort()
print(name)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'a\', \'c\', \'e\']

name = [\'c\',\'a\',\'e\']
name.sort(reverse=True)
print(name)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'e\', \'c\', \'a\']

# 临时排序，**不影响原始列表数据**，可以通过通过sorted方法里面传递参数让其反着打
name1 = [\'c\',\'a\',\'e\']
name2 = sorted(name1)
print(name1)
print(name2)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'c\', \'a\', \'e\']
[\'a\', \'c\', \'e\']

# **反着打印，永久修改**，一次使用是在上一次的基础上反转，再次使用，再反转
name = [\'c\',\'a\',\'e\']
print(name)
name.reverse()
print(name)
name.reverse()
print(name)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'c\', \'a\', \'e\']
[\'e\', \'a\', \'c\']
[\'c\', \'a\', \'e\']

# 计算列表的长度，在统计的时候比较有用，比如说统计还有多少外星人
name = [\'c\',\'a\',\'e\']
print(len(name))
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
3

四、操作列表

其实对操作最常用的操作就是遍历，而遍历列表主要通过循环去做，所以我们在这一节要接触到一些循环的知识点，也有第五章的学习打下基础。

遍历

# **需要对列表中的每个元素都执行相同操作时，可以使用for循环**
supper_start = [\'hehua\',\'xiangxiang\',\'fubao\']
for panda in supper_start:   
    print(panda)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua
xiangxiang
fubao

for panda in supper_start: 让python获取列表当中的第一个值，赋值给panda，然后执行动作，然后再次循环获取第二个值，再执行动作……，最终没有其它值了，再执行for循环之后的代码。

刚开始使用循环时请牢记，对列表中的每一个元素，都将执行循环指定的步骤，完全穷尽列表当中的所有元素之后，再会执行for循环之外的步骤，如下所示：

supper_start = [\'hehua\',\'xiangxiang\',\'fubao\']
for panda in supper_start:
    print(panda)
print("stop")

"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua
xiangxiang
fubao
stop

# 在for循环当中执行更多的操作
supper_start = [\'hehua\',\'xiangxiang\',\'fubao\']
for panda in supper_start:
    print(f\'panda.title() very cute!\')
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
Hehua very cute!
Xiangxiang very cute!
Fubao very cute!

# 在for循环结束之后执行一些操作
supper_start = [\'hehua\',\'xiangxiang\',\'fubao\']
for panda in supper_start:
    print(f\'panda.title() very cute!\')
print("all panda very cute")
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
Hehua very cute!
Xiangxiang very cute!
Fubao very cute!
all panda very cute

创建数值列表

# 使用range函数来创建数字列表   
for i in range(1,3):
    print(i)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
1
2

解释一下，明明我想打印的1,2,3为什么结果却是1,2呢？

• range(1,3）应该解释成为从1开始打印，打印到第三个数的停止，但是不包括和三个数；
• 大于等于第一个数，小于第二数，不包括第二个数。

使用range函数时，如果输出不符合预期，请尝试将指定的值加1或减1

**# 如果range里面只写一个数，那就会从零开始打印，到这个数结束，如下所示：**
for i in range(3):
	print(i)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
0
1
2

**# 使用range创建数字列表，要搭配list函数**
numbers = list(range(3))
print(numbers,type(numbers))
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[0, 1, 2] <class \'list\'>

**# 搭配步长值，第三个参数，即在第一个值的基础加步长
# 比如我们想打印1-10的奇数**
numbers = list(range(1,11,2))
print(numbers,type(numbers))
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[1, 3, 5, 7, 9] <class \'list\'>

# 乘法运算加上字符串追加
numbers = []
for i in range(1,4):
    number = i ** 2
    numbers.append(number)
print(numbers)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[1, 4, 9]

# 上述代码其实可以更简洁
numbers = []
for i in range(1,4):
    numbers.append(i ** 2)
print(numbers)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[1, 4, 9]

# 代码还可以写的更简单,其实就是把代码折叠了一下嘛，先把for写完，然后把动作写前面，注意没有冒号了
# 这种方式被叫做代码的解析
numbers = [i ** 2 for i in range(1,4)]
print(numbers)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[1, 4, 9]

这个方法经常被使用，比如说将本网段内所有的在线主机打印出来，那实现的思路：

1. 取出当前网段，假设是C类
2. 通过range（1，255）取出主机位
3. 通过ping类探测，取成功的，将其符合到某一个空列表，最终将其打印出来

# 对数字列表执行简单的统计计算
numbers = range(1,101)
print(min(numbers))
print(max(numbers))
print(sum(numbers))

使用列表的一部分：切片

• 切片的格式：LIST[x:x]，类似于range

# 只切前两个
supper_start = ["hehua",\'xingxiang\',\'fubao\']
print(supper_start[0:2]) # 等同于print(supper_start[:2])
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'hehua\', \'xingxiang\']

# 只切后两个
supper_start = ["hehua",\'xingxiang\',\'fubao\']
print(supper_start[1:])   # 等同于print(supper_start[-2:])

# 遍历切片，非常简单呀，很容易理解
supper_start = ["hehua",\'xingxiang\',\'fubao\',\'aibao\']
for panda in supper_start[0:3]:
    print(f\'panda very cute!\')
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua very cute!
xingxiang very cute!
fubao very cute!

上述这个切片非常有用，比如说取出TOP10

# 复制列表[:]
# 根据现有列表创建新的列表
japan_panda = [\'xiangxiang\']
japan_panda.append(\'zhenzhen\')

china_panda = japan_panda[:]
china_panda.append(\'hehua\')
print(f\'japan panda:japan_panda\')
print(f\'china panda:china_panda\')

"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
japan panda:[\'xiangxiang\', \'zhenzhen\']
china panda:[\'xiangxiang\', \'zhenzhen\', \'hehua\']

元组

• 列表经常用来保存在程序当中经常变化的数据集，经常变化嘛，自然也就是可以修改的。
• 但有时候我们需要来创建不需要变化的数据集，这种不可变化的列表，就叫元组，所以说当一个数据集需要在整个程序的生命周期当中保持不变，就可以用元组。
• 为了与传统的列表做一个区分，列表使用中括号，元组使用小括号
• 访问方法与列表一样

# 基本使用与列表一模一样
panda = [\'hehua\',\'heye\']
print(panda[0])
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua

panda = (\'hehua\',\'heye\')
print(panda[0])
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua

# 修改的时候就不一样了
panda = [\'hehua\',\'heye\']
panda[0] = \'guolai\'
print(panda)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
[\'guolai\', \'heye\']

# 如果像下面这样操作就会报语法错了！！元组不可修改
panda = (\'hehua\',\'heye\')
panda(0) = \'guolai\'
print(panda)

# 遍历列表
panda = [\'hehua\',\'heye\',\'fubao\']
for i in panda:
    print(i)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua
heye
fubao

# 遍历元组
panda = (\'hehua\',\'heye\',\'fubao\')
for i in panda:
    print(i)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua
heye
fubao

# 元组内的元素定义完了之后，就不能更改了
# 但元组在使用的时候是要赋值给变量的，我们可以直接修改变量
panda = (\'hehua\',\'heye\')
for i in panda:
    print(i)
panda = (\'aibao\',\'xiangxiang\')
for i in panda:
    print(i)
"C:\\Program Files\\Python311\\python.exe" G:\\python2\\黑客.py 
hehua
heye
aibao
xiangxiang