python学习，个人随笔

最新推荐文章于 2025-05-11 21:22:45 发布

aliphantom

最新推荐文章于 2025-05-11 21:22:45 发布

阅读量298

点赞数

分类专栏： Python

本文链接：https://blog.youkuaiyun.com/u013515929/article/details/108332520

版权

Python 专栏收录该内容

13 篇文章

订阅专栏

python学习，个人随笔

1. 吉多·范罗苏姆（Guido van Rossum，1956年1月31日－）是一名荷兰计算机程序员，他作为 Python 程序设计语言的作者而为人们熟知。

2. ASCII编码（英文字母） -> GB2312编码（包含中文）-> Unicode编码（各个国家）-> UTF-8编码（各个国家，可变长编码）。

3. list 和 tuple 是 Python 内置的有序集合，一个可变，一个不可变。一个用方括号 [ ]，一个用圆括号 ( )。
$\;\quad$ list是列表：[1,2,3]，tuple是元组：(1,2,3)。

4. 常量：所谓常量就是不能变的变量。在Python中，习惯上用全部大写的变量名表示常量：PI = 3.14159265359。

5. 字典：使用键-值（key-value）存储，字典 (dict) 的 key 必须是不可变对象，字典具有极快的查找速度。

>>> d = {'A': 95, 'B': 75, 'C': 85}
>>> d['A']
95

6. 集合：是一组不重复 key 的集合，但不存储 value。创建一个 set，需提供一个 list 作为输入集合。

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

7. 函数：使用def语句，依次写出函数名、括号、参数和冒号，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_add(x,y):
	return x + y

8. python 函数的返回值是一个 tuple，返回多值无需括号，写起来很方便。

import math
def my_add_sub(x, y):
    nx = x +y
    ny = x - y
    return nx, ny
r = my_add_sub(100, 50)
print(r)
>>> (150.0, 50.0)

$\;\quad$ 如上，虽然返回值只有 r 一个，其中 r 的值为一个tuple，根据索引取其中具体的值。

9. 函数参数的顺序：必选参数、默认参数、可变参数、关键字参数。

// **必选参数、默认参数**
// name 为必选参数，age 和 city 为默认参数。
def person(name, age=6, city='Beijing'):
    print('name:', name)
    print('age:', age)
    print('city:', city)
    
person('phantom', city='Tianjin') //age值保持默认值，city值需要修改。

// **可变参数**
// 可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个，其可以是一个list或tuple传递。
def my_add(*numbers):
    sum = 0
    for num in numbers:
        sum = sum + num
    return sum
my_list= [1, 2, 3]
my_add(*my_list)
>>>6

// **关键字参数**
// 关键字参数在函数内部自动组装为一个dict。
def person(name, **kw):
    print('name:', name, 'other:', kw)

person('phantom')
>>>name: phantom other: {}
person('Jack', gender='M')
>>> name:Jack other: {'gender': 'M'}
person('Amy', gender='F', city='Shanghai')
>>> name: Amy other: {'gender': 'F', 'city': 'Shanghai'}

$\;\quad$ 调用函数时如何传入可变参数和关键字参数的语法：
$\;\quad$ 可变参数可直接传入：func(1, 2, 3)，也可先组装list或tuple，再通过* args传入：func(*(1, 2, 3))；
$\;\quad$ 关键字参数可直接传入：func(a=1, b=2)，也可先组装dict，再通过** kw传入：func(**{‘a’: 1, ‘b’: 2})。

10. 切片：取列表或者元组中某一段的操作，L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。

L = ['A', 'B', 'C', 'D', 'E']

$\ \ \,\quad$ 如果第一个索引是0，则可省略：L[:3] ：[‘A’, ‘B’, ‘C’]。
$\ \ \,\quad$ 类似的，同样支持倒数切片，L[-2:]：[‘D’, ‘E’]，L[-2:-1]：[‘D’]。
$\ \ \,\quad$ 同理，tuple 和字符串 ‘xxx’ 也可以看成是一种 list，也可以用切片操作。

11. 迭代：通过for … in来遍历给定一个list或tuple，即为迭代（Iteration）。
$\ \ \,\quad$ 其中，对于字典的迭代，默认情况下 for key in d，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

12. 列表生成式：列表生成式即List Comprehensions，是python内置的非常简单却强大的可以用来创建list的生成式。
$\ \ \,\quad$ 例如要生成[1x1, 2x2, 3x3, …, 10x10]，可以写为：

>>> [x * x for x in range(1, 11)]。
 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

$\ \ \,\quad$ for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

$\ \ \,\quad$ 运用列表生成式，可以快速生成list，可以通过一个list推导出另一个list，而代码却十分简洁。

13. 生成器：一边循环一边计算的机制，称为生成器：generator。要创建一个generator，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)] //这里的L为列表
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10)) //这里的g为生成器
>>> g
<generator object <genexpr> at 0x1022ef630>

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

14. 函数式编程：函数式编程的一个特点就是，函数的参数可以为另一个函数，同时也可以返回函数。

15. 模块：一个.py文件就称之为一个模块（Module）。
$\ \ \,\quad$ 包：按目录来组织模块，称为包（Package）。
$\ \ \,\quad$ 若模块名字与其他模块冲突了，可以通过包来组织模块。每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。

16. 模块使用：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '
__author__ = 'Jack'
import sys
def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':
    test()

$\ \ \,\quad$ 第1行和第2行是标准注释，第1行注释让这个.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码。
$\ \ \,\quad$ 第4行是模块的文档注释。
$\ \ \,\quad$ 第5行使用__author__变量把作者写进去。
$\ \ \,\quad$ 第6行import sys 导入sys模块，就可以访问sys模块的所有功能。例如：
$\ \ \,\quad$ 1)运行python hello.py获得的sys.argv就是[‘Hello, world!’]；
$\ \ \,\quad$ 2)运行python hello.py Jack获得的sys.argv就是[‘Hello, Jack!’]。
$\ \ \,\quad$ 3)运行python hello.py Jack Chan获得的sys.argv就是[‘Too many arguments!’]。

17. 面向对象编程：面向对象编程（Object Oriented Programming，简称OOP），是一种程序设计思想。一个对象包含了数据和操作数据的函数，把对象作为程序的基本单元。

class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age= age
    def print_age(self):
        print('%s: %s' % (self.name, self.age))
Jack = Student('Jack Chan', 9)
Jack.print_age()
>>> Jack Chan, 9

$\ \ \,\quad$ class后面紧接着是类名，（通常是大写开头的单词）紧接着是(object，表示继承的父类)，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
$\ \ \,\quad$ 特殊方法“init”前后分别有两个下划线。__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传。

18. 面向对象三大特点：数据封装、继承和多态。

19. 访问限制：让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，就变成了一个私有变量（private）。

class Student(object):
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def print_age(self):
        print('%s: %s' % (self.__name, self.__age))

$\ \ \,\quad$ 改完后，已经无法从外部访问实例变量.__name和实例变量.__age了。

20. 继承和多态：https://www.liaoxuefeng.com/wiki/1016959663602400/1017497232674368

本博客为学习[1]之后的个人笔记，欲知详情，请参考[1]。

参考:

1. https://www.liaoxuefeng.com/wiki/1016959663602400 [link]