Python基础学习笔记

集体智慧 everyinch 86℃ 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_00010000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4

浮点数:如1.233.14-9.01,1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。

字符串:字符串是以单引号'或双引号"括起来的任意文本,比如'abc'"xyz"等等。

布尔值:在Python中,可以直接用TrueFalse表示布尔值(请注意大小写)

空值: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)函数有两个参数:xn,这两个参数都是位置参数,调用函数时,传入的两个值按照位置顺序依次赋给参数xn

默认参数:

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

默认参数可以简化函数的调用。设置默认参数时,有几点要注意:

一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前面);

二是如何设置默认参数。

举个例子,我们写个一年级小学生注册的函数,需要传入namegender两个参数:

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函数里,我们保证能接收到nameage这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了用户名和年龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。

// 和可变参数类似,也可以先组装出一个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>

创建Lg的区别仅在于最外层的[]()L是一个list,而g是一个generator。

g = (x * x for x in range(10))
for n in g:
    print(n)

迭代器

可以直接作用于for循环的数据类型有以下几种:

一类是集合数据类型,如listtupledictsetstr等;

一类是generator,包括生成器和带yield的generator function。

// 可以使用isinstance()判断一个对象是否是Iterable对象:
from collections.abc import Iterable
isinstance([], Iterable)
isinstance({}, Iterable)
isinstance((x for x in range(10)), Iterator)

面向对象编程

采用面向对象的程序设计思想,我们首选思考的不是程序的执行流程,而是Student这种数据类型应该被视为一个对象,这个对象拥有namescore这两个属性(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__方法,在创建实例的时候,就把namescore等属性绑上去:

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'>

判断基本数据类型可以直接写intstr等,但如果要判断一个对象是否是函数怎么办?可以使用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基础学习笔记

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

表情

Hi,您需要填写昵称和邮箱!

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