Python基础学习笔记

集体智慧 everyinch 516℃ 0评论

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') //删除一个key

set和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 s

power(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基础学习笔记

喜欢 (7)
发表我的评论
取消评论

表情

Hi，您需要填写昵称和邮箱！

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
'; } if( dopt('d_footcode_b') ) echo dopt('d_footcode'); ?>