Python 基础语法

NOTE：以下是基于python3的简单总结备忘。更多细节python3官方文档：https://docs.python.org/zh-cn/3/

0. python之禅

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!

1. 数据类型

• 数字（number）
  • 整数（int）：199
  • 浮点数（float）：3.141592654
• 字符串（str）：‘hello‘、"world"
• 布尔（boolean）：True False
• 类型转换
  • 符串 -> 整型：num = int(‘123‘)
  • 浮点 -> 整型：num = int(3.14)
  • 列表 -> 元组：tuple([‘cat‘, ‘dog‘, 5])
  • 元组 -> 列表：list((‘cat‘, ‘dog‘, 5))
  • 集合 -> 列表：list({‘cat‘, ‘dog‘, 5})

2. 运算符

• 算术：+ - * / % **(幂) //(取商)
• 比较：== != > < >= <=
• 赋值/复合运算：= += -= *= /= %= **= //==
• 逻辑：and or not
• 位运算：& | ^ ~ << >>
• 成员运算符（判断某一元素是否在序列中）：in not in
• 身份运算符（判断两个标识符是不是引用自一个对象）：is is not
• 集合运算符：- | & ^。详见5.1.5集合

3. 条件分支

• if

  if cond1:
      pass
  elif cond2:
      pass
  else:
      pass
  

4. 循环

• while

  while cond:
  	print(‘aaa‘)
  

  while cond1:				# 由cond1条件不满足而跳出while，会执行else中的代码
  	print(‘hello‘)
      if cond2:
          break				# 由break而跳出while，不会执行else中的代码
  else:
      print(‘world‘)
  

• for

  通式：for 变量 in 序列。序列有字符串、列表、元组……。

  for c in ‘codemao‘:
      print(c)
  

  for i in range(9):			# 由cond1条件不满足而跳出while，会执行else中的代码
      print(i)
      if i > 5:
          break				# 由break而跳出while，不会执行else中的代码
  else:
      print(‘end‘)
  

  range(start, stop, step)：生成一系列由数字组成的序列。

  start : 开始，没有默认从0开始

  stop : 结束，但不包含stop

  step : 步长

  range(6)		# 序列为：0 1 2 3 4 5
  range(1, 5)		# 序列为：1 2 3 4 
  range(1, 11, 3)	 # 序列为：1 4 7 10
  

5. 数据结构

5.1 列表（List）

列表是由一系列按特定顺序排列的元素组成。其实如C语言中的数组是类似的：下标索引也是从0开始；访问元素用array[5]；字符串也是一种列表。只不过在一些语法上有些许差别：在C语言中数组是由圆括号括起来的，但python中列表是由中括号括起来的bicycles = [‘trek‘, ‘cannondale‘, ‘redline‘, ‘specialized‘];在C语言中数组中元素的类型只能是单一的，但在python中可以是多种类型放在一个列表中list = [1, ‘hello‘, None, True]。

列表中的append、pop、insert、remove都是列表的方法，同理，元组、集合、字典……也有各自的方法。方法和函数其实是一回事，只是形式不一样。方法往往跟在一个对象后面，如a.pop()，代表的是对象的操作。而函数调用仅仅是func()，当引用模块中的函数时，则形式和方法类似，如random.randint(1, 10)。

5.1.1 列表增、删、查、改

a = [1, 2, 3, 4, ‘codemao‘]

a.append(5)         # 增加在末尾
a[1] = 100          # 修改索引为1的元素
del a[1]            # 删除索引为1的元素
num = a.pop(1)      # 弹出索引为1的元素并赋值给num。如a.pop(),则默认弹出列表末尾的元素
a.remove(‘codemao‘) 	# 删除值为‘codemao‘的元素
a.insert(1, ‘hello‘)	# 在索引为1的地方插入‘hello‘,其余元素向后移一位

# 列表拼接、复制
a += [‘x‘, ‘y‘]*2	# 拼接用 +，复制用 *

5.1.2 创建数字列表、排序

numbers = list(range(1,6))						# 创建[1, 2, 3, 4, 5]的名为numbers的列表
squares = [value**2 for value in range(1,6)]	# 生成[1, 4, 9, 16, 25]的名为squares的列表
slen = len(squares)								# 求squares的长度，即元素个数

a = [1, 10, 3, 6, 8]
a.sort()            # 永久改变a的顺序
b = sorted(a)       # 生成了a排序后的副本，并不改变a的顺序
a.reverse()         # 永久改变a的顺序,逆序

5.1.3 切片（Slice）

当需要访问或使用列表中一部分元素时，则会用到切片技术。既然说到切片，那就不得不提python中列表的索引方式了，这点和C语言有点不同。在python中列表有2种索引方式：正向和反向。

以列表长度为5的列表为例：
正向从左至右分别为：0 1 2 3 4
反向从右至左分别为：-5 -4 -3 -2 -1

在使用切片时，灵活使用索引会方便不少，也能使代码易于阅读。
切片的基本形式：listname[4:9]。和range类似，它也是“含头不含尾”， 同时也可以用步长。具体代码如下：

a = [1, 10, 3, 6, 8]

print(a[1:4])       # 切取索引从1到3的元素并生成一个新的列表
print(a[:3])        # 切取索引从0到2的元素并生成一个新的列表
print(a[-3:])       # 切取索引从-3到-1的元素并生成一个新的列表
print(a[1:8:2])     # 切取索引从1、3的元素并生成一个新的列表
b = a[:]            # 生成a的一个副本

这里应当注意的是，要复制一个列表，应当使用切片。如果仅仅用=，则是让2个不同的变量指向同一个列表。如：

a = [1, 10, 3, 6, 8]
b = a					# 将a赋值给b
b.append(100)

print(id(a), id(b))
print(a, b)
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
运行结果：
43022216 43022216
[1, 10, 3, 6, 8, 100] [1, 10, 3, 6, 8, 100]

5.1.4 元组（Tuple）

元组也是一种列表（用圆括号），故放在列表中讲。在python中有可变对象和不可变对象，元组就是不可变对象，当一个元组创建后，就不能改变其中元素的值。但修改存储元组变量的值。

a = (1, 10, 3, 6, 8)

# 会报错：TypeError: ‘tuple‘ object does not support item assignment
a[4] = 9                
a = (100, 50)           # 合法 legal

5.1.5 集合（Set）

集合也是一种列表（用花括号），集合是一个无序的且不重复的元素序列。如：

a = {1, 2, 3, 4}			# 创建一个集合

集合运算主要有4种：

a = {4, 5, 6}
b = {1, 4, 7}
print(a-b)      # 集合a中包含而集合b中不包含的元素。相当于a-a&b
print(a|b)      # 集合a或b中包含的所有不重复的元素
print(a&b)      # 集合a和b中同时包含了的元素
print(a^b)      # 不同时包含于a和b的元素
# -------------------------------
运行结果：
{5, 6}
{1, 4, 5, 6, 7}
{4}
{1, 5, 6, 7}

5.2 字典（Dic）

字典是一系列的键(key)－值(value)对，每个键与一个值相关联。与C语言中struct类似。

字典中的表项是不排序的，当故使用字典中的表项时，不能用下标来索引，可用键来索引。

其中，字典的值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行
1. 同一个键不允许出现2次，若同一个键被赋值2次，以后一次赋值为准
2. 键必须不可变，可以用number/str/tuple。

d = {‘size‘:42, ‘maker‘:‘Nike‘, ‘color‘:‘orange‘}		# 创建字典
print(d[‘make‘])			# 用key来索引
d[‘size‘] = 44				# 修改
del d[‘color‘]				# 删除k-v对

• 方法

  • keys()、values()、items()。这些方法返回的值不是真正的列表，它们不能被修改，也没有append方法，但它们可用于for循环来遍历字典

    spam = {‘color‘: ‘red‘, ‘age‘: 42}
    for v in spam.values():
        print(v)
    

  • get(key, retval)方法是取相应key所对应的值。key是要取得其值的键，retval是如果该键不存在时，返回的备用值。

    picnicItems = {‘apples‘: 5, ‘cups‘: 2}
    print(str(picnicItems.get(‘cups‘, 0)) + ‘ cups.‘)
    print(str(picnicItems.get(‘eggs‘, 0)) + ‘ eggs.‘)
    #-----------------------
    运行结果：
    2 cups.
    0 eggs.
    

  • setdefault(key, def_value)方法是为字典中某个键设置一个默认值。def_value是默认值。

    spam = {‘name‘: ‘Pooka‘, ‘age‘: 5}
    spam.setdefault(‘color‘, ‘black‘)           # color被设置为black
    spam.setdefault(‘color‘, ‘white‘)           # color被未设置为white，还是black
    

6. 函数

6.1 定义与调用

# 定义
def f1(arg1, arg2, arg3...):
    arg1 = arg2 + arg3
    return arg1					# 返回值可以Number，也可以是List

# 调用
f1(3, 4, 5)

6.2 参数传递

def describe(name, gender, age)			# 位置实参。调用时实参与形参位置要一一对应

def describe(name, gender, age)
describe(gender=‘male‘, age=23, name=‘James‘)		# 关键字实参。不需要一一对应

def describe(name, gender, age=23)		# 默认值。调用时如无age实参，则为23
def describe(name, gender, age=‘‘)		# 可选参数。调用时age实参可有可无

def mul(*n):		# 不定长参数
mul(3, 4, 5)		# 调用时可以有n个实参	

不可变对象（int/string/turple/set），传递的只是n1, n2的副本。相当于C语言值传递

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)				
print(id(a))
print(a)

4379369136
4379369136
4379369424
4379369436
1
程序运行结束

可变对象（list/dic），传递的是n1, n2本身。相当于C语言指针传递

def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
程序运行结束

6.3 作用域

可以将“作用域”看成是变量的容器。当作用域被销毁时，所有保存在该作用域内的变量的值就被丢弃了。

全局变量：在所有的函数之外赋值的变量具有全局作用域，是全局变量。

局部变量：处于局部的变量称为局部变量。

• 局部变量不能在全局作用域内使用

  def f():
      a = 100
  f()
  print(a)
  

  运行结果：NameError: name a is not defined

• 局部作用域不能使用其他局部变量

  def f1():
      a = 100
      f2()
      print(a)
  
  def f2():
      b = 10
      a = 120
  f1()
  

  运行结果：100。不同局部作用域间是相互独立的，它们之间的变量也是相互独立的。

• 全局变量也能在局部作用域中使用

  def spam():
      print(eggs)
  eggs = 42
  spam()
  

  运行结果：42。

  如果在函数体中，没有变量名为eggs，也没有代码为eggs赋值，则在spam()中使用eggs时，python就默认其对全局变量的引用。

  所以如果出现局部变量和全局变量重名的情况，会令人迷惑：

  def spam():
      eggs = ‘spam local‘
      print(eggs)  # prints ‘spam local‘
  
  def bacon():
      eggs = ‘bacon local‘
      print(eggs)  # prints ‘bacon local‘
      spam()
      print(eggs)  # prints ‘bacon local‘
  
  eggs = ‘global‘
  bacon()
  print(eggs)  # prints ‘global‘
  

  运行结果：

  bacon local
  spam local
  bacon local
  global
  

  所以就避免这种情况。

  如果想在局部作用域中改变全局变量的值，则应使用global：

  def spam():
      global eggs
      eggs = ‘spam‘
  eggs = ‘global‘
  spam()
  print(eggs)
  

  运行结果：spam。

7. 异常

一般情况下，每当Python遇到不知所措的错误时，程序将停止，并显示一个traceback，其中包含异常的报告。如果用try-except处理，即使发生异常，程序也将继续运行，并显示出你编写的友好错误消息。

一般情况：

def div(n):
    return 42 / n

print(div(5))
print(div(0))
print(div(3))

8.4
Traceback(most recent call last):
.....
ZeroDivisionError: division by zero

用try-except处理后的情况：

def div(n):
    try:
        answer = 42 / n
    except ZeroDivisionError:					# 如果发生异常则执行此代码
        print(‘Error: Cannot div by zero‘)
    else:									  # 如果未发生异常则执行else	
        return answer

print(div(5))
print(div(0))
print(div(3))

8.4
Error: Cannot div by zero
None
14.0

8. 文件

8.1 读文件

filename = ‘pi_digits.txt‘
with open(filename) as file_object:				# 打开.txt文件
    lines = file_object.readlines()				# 逐行读取到lines列表中
for line in lines:
    print(line.rstrip())					

8.2 写文件

filename = ‘programming.txt‘
with open(filename, ‘w‘) as file_object:			# 以写方式打开文件
    file_object.write("I love programming.")		# 向文件中写入内容

常用模式：‘r‘(读模式)、‘w‘(写模式)、‘a‘(附加模式)

这些模式和C语言的文本操作是类似的，可以借鉴。

9. 类

• 创建类、实例

# 创建类。一般来说在Python中， 首字母大写的名称指的是类
class Car():
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0               # 属性默认值
    def get_descriptive_name(self):
        return (str(self.year) + ‘ ‘ + self.make + ‘ ‘ + self.model)
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " + str(self.odometer_reading) + " miles on it.")

# 创建实例
my_new_car = Car(‘audi‘, ‘a4‘, 2016)

# 调用类中的方法
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

• 继承

# 创建子类，继承于Car
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性。父类也称为超类"""
        super().__init__(make, model, year)
        self.battery_size = 70              # 子类特有属性

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")
    
    # 亦可重写父类方法
    def fill_gas_tank():
        """电动汽车没有油箱"""
        print("This car doesn‘t need a gas tank!")

# 创建实例
my_tesla = ElectricCar(‘tesla‘, ‘model s‘, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

• 类“嵌套”

# 将ElectricCar中的battery再抽象出一个Battery类
class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size = battery_size
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

# 创建子类，继承于Car
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性。父类也称为超类"""
        super().__init__(make, model, year)
        self.battery = Battery()            # 创建Battery实例
    
    # 亦可重写父类方法
    def fill_gas_tank():
        """电动汽车没有油箱"""
        print("This car doesn‘t need a gas tank!")

# 创建实例
my_tesla = ElectricCar(‘tesla‘, ‘model s‘, 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()    def describe_battery(self):

• 导入类

from car import Car						# 导入一个类
my_new_car = Car(‘audi‘, ‘a4‘, 2016)

from car import Car, ElectricCar		# 导入多个类
my_tesla = ElectricCar(‘tesla‘, ‘roadster‘, 2016)

import car								# 导入整个模块
my_beetle = car.Car(‘volkswagen‘, ‘beetle‘, 2016)

• 当模块之间有依赖关系时，必须导入被依赖的模块。如 ElectricCar类依赖于Battery类，那么编写ElectricCar类时，必须先在文件开头导入Battery类的模块名。

10. 模块

除了python自带的标准库，我们也可以安装其他第三方模块来拓展python的功能。

安装方法：

1. 安装pip工具

   Win和OS X可能在下载python3时已默认安装。Linux：get install python3-pip 。安装完后，Win上pip位于C:\Python34\Scripts\pip.exe ；OS X上，位于/Library/Frameworks/Python.framework/Versions/3.4/bin/pip3 ；Linux上，位于/usr/bin/pip3

2. 安装第三方模块

   Win上，运行pip install ModuleName ；OS X或Linux上，运行sudo pip3 install ModuleName

python 基础语法

原文：https://www.cnblogs.com/rogerg6/p/14401944.html