Python基础
python基础
Python的语法比较简单，采用缩进方式，写出来的代码就像下面的样子：
# print absolute value of an integer:
a = 100
if a >= 0:
print(a)
else:
print(-a)以#开头的语句是注释
Python使用缩进来组织代码块，请务必遵守约定俗成的习惯，坚持使用4个空格的缩进。
在文本编辑器中，需要设置把Tab自动转换为4个空格，确保不混用Tab和空格。
数据类型和变量
整数：十六进制用0x前缀和0-9，a-f表示。Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。
浮点数：如1.23，3.14，-9.01，1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
字符串：字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。
布尔值：在Python中，可以直接用True、False表示布尔值（请注意大小写）
空值：None
变量：
常量：所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：
PI = 3.14159265359使用list和tuple
list是一种有序的集合，可以随时添加和删除其中的元素。
classmates = ['Michael', 'Bob', 'Tracy']
len(classmates) // 元素的个数
classmates[0]
classmates[-1] // 最后一个元素
classmates.append('Adam')
classmates.insert(1, 'Jack')
classmates.pop() //删除list末尾的元素
classmates.pop(1) //要删除指定位置的元素，用pop(i)方法
s = ['python', 'java', ['asp', 'php'], 'scheme'] // 可以嵌套tuple：元组，tuple一旦初始化就不能修改
classmates = ('Michael', 'Bob', 'Tracy')现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
条件判断
if语句：
age = 20
if age >= 18:
print('your age is', age)
print('adult')
// 或者有else的情形
age = 3
if age >= 18:
print('your age is', age)
print('adult')
else:
print('your age is', age)
print('teenager')
// elif
age = 3
if age >= 18:
print('adult')
elif age >= 6:
print('teenager')
else:
print('kid')模式匹配
match语句：
score = 'B'
match score:
case 'A':
print('score is A.')
case 'B':
print('score is B.')
case 'C':
print('score is C.')
case _: # _表示匹配到其他任何情况
print('score is ???.')使用match匹配列表：
args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']
match args:
# 如果仅出现gcc，报错:
case ['gcc']:
print('gcc: missing source file(s).')
# 出现gcc，且至少指定了一个文件:
case ['gcc', file1, *files]:
print('gcc compile: ' + file1 + ', ' + ', '.join(files))
# 仅出现clean:
case ['clean']:
print('clean')
case _:
print('invalid command.')循环
Python的循环有两种，一种是for…in循环，依次把list或tuple中的每个元素迭代出来，看例子：
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print(name)
sum = 0
for x in range(101):
sum = sum + x
print(sum)第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)dict和set
dict相当于map，使用键值对（key-value）存储
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael'] //95
d['Jack'] = 90 //通过key放入value
d.get('Thomas', -1) // 避免key不存在报错，通过get方法，如果key不存在，可以返回None，或指定的value
d.pop('Bob') //删除一个keyset和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
s = set([1, 2, 3])
s = set([1, 1, 2, 2, 3, 3]) // {1,2,3}，重复元素被过滤
s.add(4) // 添加元素到set中
s.remove(4) // remove(key)可以删除元素
// 可以做交集、并集的操作
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2
{2, 3}
s1 | s2
{1, 2, 3, 4}函数
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
def my_abs(x):
if x >= 0:
return x
else:
return -x
from abstest import my_abs // 从abstest导入my_abs函数
// 定义什么也不做的函数
def nop():
pass
// 对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
// 返回多个值
import math
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny函数的参数
位置参数：除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数
// 用来计算x^n
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return spower(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。
默认参数：
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s默认参数可以简化函数的调用。设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。
举个例子，我们写个一年级小学生注册的函数，需要传入name和gender两个参数：
def enroll(name, gender):
print('name:', name)
print('gender:', gender)
// 如果要继续传入年龄、城市等信息怎么办？我们可以把年龄和城市设为默认参数：
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
// 默认参数的坑
def add_end(L=[]):
L.append('END')
return L
add_end()
['END']
add_end()
['END', 'END']
add_end()
['END', 'END', 'END']
// 修改上面的例子
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L可变参数：变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
calc([1, 2, 3]) // 14
calc((1, 3, 5, 7)) // 84
calc(1, 2, 3) // 14 如果利用可变参数，调用函数的方式可以简化
calc(1, 3, 5, 7) // 84
// 把函数的参数改为可变参数：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum关键字参数：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
person('Michael', 30) // name: Michael age: 30 other: {}
person('Bob', 35, city='Beijing') //name: Bob age: 35 other: {'city': 'Beijing'}关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
// 和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
// 当然，上面复杂的调用可以用简化的写法：
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}命名关键字参数：对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
// 仍以person()函数为例，我们希望检查是否有city和job参数：
def person(name, age, **kw):
if 'city' in kw:
# 有city参数
pass
if 'job' in kw:
# 有job参数
pass
print('name:', name, 'age:', age, 'other:', kw)
// 如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
// 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)参数组合：在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)高级特性
构造一个1, 3, 5, 7, ..., 99的列表，可以通过循环实现：
L = []
n = 1
while n <= 99:
L.append(n)
n = n + 2切片
取一个list或tuple的部分元素是非常常见的操作。
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3] // 从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
// 如果第一个索引是0，还可以省略：
L[:3]
L[1:3] //从索引1开始，取出2个元素
L[-2:] //['Bob', 'Jack']
L[-2:-1] //['Bob']
L = list(range(100)) // 创建一个0-99的数列
L[:10] // 取出前10个数
L[-10:] // 后10个数
L[10:20] //前11-20个数
L[:10:2] //前10个数，每两个取一个，[0, 2, 4, 6, 8]
L[::5] //[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]迭代
在Python中，迭代是通过for ... in来完成的。
d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
print(key)
for ch in 'ABC':
print(ch)默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。
如何判断一个对象是可迭代对象呢？方法是通过collections.abc模块的Iterable类型判断：
from collections.abc import Iterable
isinstance('abc', Iterable) # str是否可迭代Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
for i, value in enumerate(['A', 'B', 'C']):
print(i, value)列表生成式
列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：
// 如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？方法一是循环：
L = []
for x in range(1, 11):
L.append(x * x) //[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
// 列表生成式的写法：
[x * x for x in range(1, 11)]
//for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：
[x * x for x in range(1, 11) if x % 2 == 0] //[4, 16, 36, 64, 100]
// 还可以使用两层循环，可以生成全排列：
[m + n for m in 'ABC' for n in 'XYZ'] // ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
生成器
在Python中，这种一边循环一边计算的机制，称为生成器：generator。
L = [x * x for x in range(10)] // [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
g = (x * x for x in range(10)) // <generator object <genexpr> at 0x1022ef630>创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。
g = (x * x for x in range(10))
for n in g:
print(n)迭代器
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
// 可以使用isinstance()判断一个对象是否是Iterable对象：
from collections.abc import Iterable
isinstance([], Iterable)
isinstance({}, Iterable)
isinstance((x for x in range(10)), Iterator)面向对象编程
采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))类和实例
类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
class Student(object):
pass
bart = Student()通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
bart = Student('Bart Simpson', 59)数据封装：直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))访问限制
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
class Student(object):
// name和score成为了私有变量
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print('%s: %s' % (self.__name, self.__score))如果外部代码要获取name和score怎么办？可以给Student类增加get和set这样的方法：
class Student(object):
...
def get_name(self):
return self.__name
def get_score(self):
return self.__score
def set_score(self, score):
self.__score = score继承和多态
当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
pass
class Cat(Animal):
pass继承有什么好处？最大的好处是子类获得了父类的全部功能。
dog = Dog()
dog.run()
cat = Cat()
cat.run()当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。
当我们定义一个class的时候，我们实际上就定义了一种数据类型。判断一个变量是否是某个类型可以用isinstance()判断：
a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型
isinstance(a, list) //True
isinstance(b, Animal) //True
isinstance(c, Dog) //True
isinstance(c, Animal) //True
b = Animal()
isinstance(b, Dog) //False这时我们再编写一个函数，这个函数接受一个Animal类型的变量：
def run_twice(animal):
animal.run()
animal.run()
run_twice(Animal())
Animal is running...
Animal is running...
run_twice(Dog())
Dog is running...
Dog is running...
run_twice(Cat())
Cat is running...
Cat is running...获取对象信息
当我们拿到一个对象的引用时，如何知道这个对象是什么类型、有哪些方法呢？
首先，我们来判断对象类型，使用type()函数：
type(123) // <class 'int'>
type('str') //<class 'str'>
type(None) //<type(None) 'NoneType'>判断基本数据类型可以直接写int，str等，但如果要判断一个对象是否是函数怎么办？可以使用types模块中定义的常量：
import types
def fn():
pass
type(fn)==types.FunctionType //True
type(abs)==types.BuiltinFunctionType //True
type(lambda x: x)==types.LambdaType //True
type((x for x in range(10)))==types.GeneratorType //True对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。
a = Animal()
d = Dog()
h = Husky()
isinstance(h, Husky) //True如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：
dir('ABC')
['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']实例属性和类属性
如果Student类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有：
class Student(object):
name = 'Student'转载请注明：陈童的博客 » Python基础学习笔记
