python

前言

关于python的学习早就想提上日程了，但禁不住诱惑一直不停的地拖，一直到了今天，我也已经军训完，翘了编程实战回到家里无所事事。恰巧，关于python学习的书也到了，那就索性开始慢慢学吧，随便还能做个笔记，留给之后的小孩们看看。

Hello World

print("Hello world!")

这是学习每个语言的第一句话，传说这样，会给你的语言学习带来好运哦。

python之禅

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!
hitokoto: true

python：蛇皮书

大妈的建议：

• 第一部分快速浏览，尽量在42h内完成（虽然我感觉有点困难），不用理解，眼熟就行。
• 第二部分精读，根据第一部分基础知识点自我答疑。

变量和简单的数据类型

变量

explem:

message = "Hello world!"

1. 变量的命名：
   • 变量名由字母、下划线、数字组成，数字不能开头
   • 不要把python关键字和函数名作为变量名
   • 慎用小写字母l和o（易与1、0混淆）
2. 变量是标签

字符串

1. 字符串可以是单引号也可以是多引号

   "This is a string"
   'This is a string'

2. 修改大小写

   • example

     name = 'This is a string'
     print(name.title()) # 让python对name执行title（）操作，title（）第一个字符大写，其余小写

   • 同理，name.upper()

   • name.lower()

3. 字符串中插入变量

   first = "hello"
   last = 'xiao xue'
   all = f"{first},my name is {last}."
   print(all)

   这种字符串名叫f字符串，f在前引号前面，在python3.6版本引入，在此之前的版本用format（）

   all = "{},my name is {}.".format(first,last)

4. 添加空白
   ‘/n’:换行
   ‘/t’:制表
5. 删除空白
   • 删除开头的空白name.lstrip()
   • 删除结尾的空白name.rstrip()
   • 删除两边的空白name.strip()
   • 上述删除是暂时的，永久删除需要

     name = name.strip()

数

1. 整数
   • 可以正常加减乘除运算
   • 乘方运算“x**y”

     >>> 3**2
     9

   • 求模运算符 %
2. 浮点数
3. 整数和浮点数
   • 两数相除，结果总是浮点数
   • 有一个操作数是浮点数，结果也是浮点数。
4. 下划线（3.6版本及以上支持）
   用来表示很大的数字，python会自动忽略’_’

   >>> universe_age = 14_000_000_000
   >>> print(universe_age)
   14000000000

5. 多变量赋值

   >>> x,y,z = 0,0,0

6. 常量
   全大写表示常量

   MAX = 5000

注释

‘#’为python的注释符

---

列表简介

什么是列表

1. 在python中，用[ ]表示列表，”,”分割元素，比如

   >>> letter = ["A","B","c"]
   >>> print(letter)
   ["A","B","c"]

   看起来像是一个笨笨的数组（ ？）
2. 访问列表元素

   print(letter[0]) # "A"

3. 索引
   • 索引从0开始
   • 索引“—x”表示倒数第x个，比如letter[-1]是“C”

修改、添加和删除元素

1. 修改

   letter[0] = "D" # letter的第一个就从"A"变成"D"了

2. 添加

   • 在列表末尾添加:append(附加)

     letter.append('D') # 变成['A','B','C','D']

   • 插入：insert()

     letter.insert(0,'D') # 变成['D'，'A','B','C']

3. 删除

   • del

     del letter[1] # ['A','C']

   • pop()

     first = letter.pop(0) # first = "A",letter = ['B','C']

   • 根据值删元素:remove()

     # 删除"A"
     letter.remove('A')
     或是
     as = 'A'
     letter.remove(as)

     但是remove（）只能删除第一个特定的值，如果要全部删了，需要循环

组织列表

1. sort()永久排序
   • letter.sort()按照字母排序
   • letter.sort(reverse=True)逆字母排序
2. sorted()临时排序
   • example:

     print(sorted(letter))

   • 同sort(),reverse=True逆字母排序
3. 倒着打印列表(永久)

   letter.reverse()
   print(letter)

4. 确定列表长度

   print(len(letter))

操作列表

for循环

1. example:

   letters = ['A','B','C']
   for letter in letters:
    print(letter)

2. 在python中,for循环好像要更笨一点，’letter’作为临时变量，’letters’作为列表（数组），但是好像只能从头开始，一直到结尾。
3. for循环的结束：for后面有缩进的都是for里面的内容，循环一直到无缩进的时候结束。
4. 易错点：
   • 忘记缩进
   • 不必要缩进
   • 遗漏了冒号

     tip:与c和c++不同，在python中，缩进也十分重要

创建数值列表

1. range()函数
   • example:

     for value in range(1,5)
        print(value)

     结果为：

     1
     2
     3
     4

     即，对于range(x,y)，打印范围为[x,y)

     tip:range(x)==range(0,x)

   • range还能指定步长Z，example：

     #生成2~10的偶数
     for value in range(2,11,2)
        print(value)

   • 使用range()创建数字列表

     number = list(range(1,6)) # 等于number=[1,2,3,4,5]

2. 对数字列表进行简单统计

   numbers = [1,2,3,4,5]
   min(numbers) # 最小
   max(numbers) # 最大
   sum(numbers) # 求和

3. 列表解析，example：

   squares = [value**2 for value in range(1,11)]
   # squares = [1,4,9,16,25,36,49,64,81,100]

   “value**2”是表达式，生成要储存在列表中的值，”for value in range(1,11)”给表达式提供值。

使用列表的一部分

看来只是和数组玩法不一样，不能说它是笨笨的

1. 切片：列表的一部分
   • example:

     letters = ['A','B','C','D']
     print(letters[0:3]) # A B C 

     与range(x,y)的范围相同，[x:y]==[x,y)

     tip: 注意别忘记”:”

   • 如果省略起始索引，如letters[:3]，则默认起始索引为0;同理，如果省略终止索引，如letters[0:]，则默认一直到列表末尾
   • 可以设置第三个值，步长Z

     tip: 索引可以用负数，比如：letters[-3:]

2. 复制列表

   letters = ['A','B','C','D']
   letters_1 = letters[:]

元组：不可变的列表 常数组（ ？）

定义元组：

letters = ('A','B','C','D')

1. 用的()而不是[]
2. 严格来说，元组是用’,’标识的，如果要定义一个一个元素的元组（虽然这样看起来很没有必要），应该定义为letters = (‘A’,)

   tip: 元组元素不能修改，但是可以重新定义（滑稽笑）

if语句

example:

letters = ["A","B","C","D"]
for letter in letters:
   if letter == 'A':
      print(letter.upper())
   else
      print(letter.title())

1. 检查多个条件
   • and == C语言里的&&
   • or == C语言里的||
   • in 检查特征值在不在列表中
   • not in 检查特征值是不是不在列表
   • 空列表返回Flase
2. if-else 和 if-elif-else

字典

听起来很nb，但是，看着，好像就是一个结构体，乐。就像这样:

alien_0 = {'color':'green','points':5}
print(alien_0['color'])
print(alien_0['points'])

在python中，如 ‘color’:’green’ 被看作一个键值对，其中 ‘color’ 是键， ‘green’ 是值，它们由 “ ：” 分隔开，键值对之间用 “ ，” 分开。不就是结构体里面的变量和值嘛

对字典的基本使用

1. 访问
   字典名[键名],如：alien_0[‘color’]
   就像是c++中定义了一个结构体me（且me .name = “ABC”）以后，me.name一样

   tip: 注意 ‘ ‘

2. 添加
   字典名[要添加的键名] = 值
   example: alien_0[‘x_position’] = 0
3. 修改
   example：
   如果之前已经有 alien_0[‘x_position’] = 0
   则 alien_0[‘x_position’] = 10
   可以将 alien_0[‘x_position’] 的值修改为10
4. 删除
   使用 del语句
   example: del alien_0[‘x_position’]
5. 使用get()来访问值
   当指定的键不存在时，比如访问一个不存在的键 alien_0[‘x_position’] 时，python会报错，此时：

   alien_0 = {'color':'green','points':5}
   
   point_value = alien_0.get('x_position','反馈的信息（随便写啥）')
   print(point_value)

   其中，第一个参数必不可少，用于指定 键 ，第二个则是反馈的信息。如果没有第二个参数，将返回None

   tip: 如果要分行定义字典，别忘了缩进（后括号也要缩进）

遍历字典

1. 遍历所有键值对： items()

   alien_0 = {'color':'green','points':5}
   
   for key,value in alien_0.items():
      print(f"{key}:{value}")

   • for中申明了两个变量 key 和 value
   • items()返回一个键值对列表
2. 遍历所有键： keys()
   同items()类似，keys()返回的是键的一个列表

   tip: 既然是列表，那就能按照某个特定顺序输出，比如用sorted()：

   ······
   for key in sorted(alien_0.keys()):
   ······

3. 遍历所有值: values()
   但是值往往会有很多重复的信息，此时我们可以用集合(set)剔除重复项

   ······
   for key in set(alien_0.keys()):
   ······

   关于集合：不同于字典和列表，集合不会以某种顺序存储元素，同时，由于集合也是用 {} 定义的，所以要小心和字典混淆（虽然感觉可能性应该不大）。集合定义，example： languages = {‘python’,’C++’,’C’}

嵌套

1. 序列里面套字典，example：

   alien_0 = {'color':'red','points':15}
   alien_1 = {'color':'black','points':10}
   alien_2 = {'color':'white','points':5}
   
   aliens = [alien_0,alien_1,alien_2] # 序列里面套字典

   tip: 可以用for和range()自动生成一堆相同外星人（字典）,然后加入在aliens（列表）中，后续可以修改

2. 字典里套列表,example

   pizza = {
      'crust':'thick', # 注意逗号
      'toppings':['1','2'] # 字典里套列表
      } # 后括号注意缩进
   
   print("A"
      "B")
   print("\t"+topping)

3. 字典套字典
   懒得写了，就是那样的，懂得都懂，记得注意缩进就好。

用户输入和while循环

说实话，这是我认为最激动人心的时刻，因为，相对于c++一来就学cin、cout，直到现在，python才给我展示了我们是如何输入的？程序是如何进行交互的？从现在开始，python才不是那么死板、单一、冰冷、无聊。 在这之前，我一直觉得C++更加有趣，因为cin、cout

用户输入

1. 变量名 = input(“参数，对输入的提示说明”) 如：name = input(“输入名字： “)
2. 使用int()获得数值输入（而不是字符串），如： age = int(“输入年龄”)

while循环

example:

num = 1
while num <= 5:
   print(num)
   num+=1

1. 标志
   这玩意很有用 （至少比我这个摸鱼仔有用太多了）
2. break
   这也是个好东西，简单而且实用，但是由于它太简单了，所以我准备摸鱼了，但是它很实用，如果不会的话，会很难受的，相信我。
3. continue
   同上

while处理列表和字典

知道了一些关于while循环的基本语法，那现在就该开始发车了，比如，while和列表、字典结合（ ？）

1. 在列表之间移动元素
2. 删除特定值的所有列表元素
3. 使用用户输入填充字典

函数

定义函数

def pets(name,old): # def是函数定义关键字，pets()是函数名
   """问候""" # 文档字符串的注释，描述函数是干嘛的
   函数主体，略

pets("Jerry",10) # 函数调用

函数传参

1. 位置实参

   pets("Jerry",10)

   （就是一般的传参啦，说得这么高级，把我给吓一跳）
2. 关键词实参

   pets(name="Jerry",old=10)

3. 默认值
   这玩意就完全不需要赘述了吧，记得设置默认值从右边开始

返回值：return

1. 让实参变成可选的
   加一个“if-elif-else”
2. 返回字典

函数与列表

1. 把列表传递给函数，函数可以对它进行 永久性的 修改
2. 如果禁止修改的话，传参的时候可以使用切片传参，将副本作为参数传递过去: function_name(list_name[:])

传递任意数量的实参

有时候，预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。

1. *创造空元组

   def make_pizza(*toppings):
      """打印顾客点的所有配料"""
      print(toppings)
   
   make_pizza('A')
   make_pizza('A','B','C')

   *toppings中的 * 表示创造一个名叫toppings的空元组。（神奇，C++也有类似的操作吗？只怪才学疏浅，一时想不到）

   tip: 你经常能看见通用形参名 *args，它也收集任意数量的位置实参

2. **创造空字典
   与*创造空元组类似

   tip: 你经常能看见通用形参名 **kwarge，它也收集任意数量的关键字实参

函数与模块

1. 导入整个模块
   1. 创建一个新文件 module_name . py （模块）
   2. 将函数定义在 module_name.py文件中
   3. 在需要调用该函数的文件中写 import module_name

      tip: 调用函数的时候，需要使用句点表示法，即module_name.function_name

2. 导入特定函数

   from module_name import function_0,function_1,function_2

   tip: 这样导入的不需要句点表示法

3. as:指定别名

   from module_name import function_name as fn # 给函数指定别名
   import module_name as mn # 给模块指定别名

4. 导入模块中的所有函数

   from module_name import *

   和“导入特定函数”一样，不需要句点表示法，但是不建议，因为这样可能会覆盖掉同名函数

类

总算到面向对象编程了，所以，你对象呢？如果没有的话，这边建议你来创一个，就像下面这样。

创建和使用类

1. 创建

   class Dog:  # 首字母大写
      """一次模拟小狗的简单尝试"""
   
      def _init_(self,name,age)
         """类似于C++构造函数"""
         self.name=name
         self.age=age
   
      def sit(self)
         """模拟小狗坐下"""
         print(f"{self.name} is now sitting.")

   !!! tip self 非常重要，它是指向实例本身的引用，必须写在第一个，不能省略

2. 使用

   my_dog=Dog('White',6)
   
   print(f"{my_dog.name} now is {my_dog.age} years old.")
   my_dog.sit()

依旧是用我们熟悉的 句点表示法 表示
3. 可以用类函数（在Python中叫做方法）修改类的属性的值

继承