Python学习笔记（一）——Python基础

心已赠人 2022-09-29 13:57 231阅读 0赞

本文是[廖雪峰的Python教程][Python]的笔记，主要是摘抄一些重点。所以我把他划分到转载里。侵删。

## 1. .py执行 ##

在命令行模式下，可以执行python进入Python交互式环境，也可以执行python hello.py运行一个.py文件

## 2.输入输出 ##

print()会依次打印每个字符串，遇到逗号“,”会输出一个空格

![20170316070004074][]

例子：

name = input('please enter your name: ')
    print('hello,', name)

input()返回的数据类型是str。

## 3.整数/浮点数 ##

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5。

整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

## 4.转义字符 ##

'I\\'m \\"OK\\"!'表示的字符串内容是：I'm "OK"!

为了简化，Python还允许用r''表示''内部的字符串默认不转义

>>> print('\\\t\\')
    \       \
    >>> print(r'\\\t\\')
    \\\t\\

如果字符串内部有很多换行，用\\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容，可以自己试试：

>>> print('''line1
    line2
    line3''')
    line1
    line2
    line3

## 5.空值 ##

用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

## 6.除法 ##

在Python中，有两种除法，一种除法是/：

>>> 10 / 3

3.3333333333333335

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

>>> 9 / 3

3.0

还有一种除法是//，称为地板除，两个整数的除法仍然是整数：

>>> 10 // 3

你没有看错，整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。

因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

>>> 10 % 3

## 7.字符编码 ##

最早只有127个字符被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122。

但是要处理中文显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

Unicode把所有语言都统一到一套编码里，但最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。

字母A用ASCII编码是十进制的65，二进制的01000001；

字符0用ASCII编码是十进制的48，二进制的00110000，注意字符'0'和整数0是不同的；

汉字中已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。

你可以猜测，如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。

果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：

![20170316070241825][]

UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

## 8. 字符串 ##

>>> ord('A')
    65
    >>> ord('中')
    20013
    >>> chr(66)
    'B'
    >>> chr(25991)
    '文'

要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。

以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：

>>> 'ABC'.encode('ascii')
    b'ABC'
    >>> '中文'.encode('utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    >>> '中文'.encode('ascii')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

在bytes中，无法显示为ASCII字符的字节，用\\x\#\#显示。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')
    'ABC'
    >>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
    '中文'

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

>>> len(b'ABC')
    3
    >>> len(b'\xe4\xb8\xad\xe6\x96\x87')
    6
    >>> len('中文'.encode('utf-8'))
    6

可见，1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。

在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

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

申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码。

## 9. 格式化 ##

>>> 'Hello, %s' % 'world'
    'Hello, world'
    >>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
    'Hi, Michael, you have $1000000.'

你可能猜到了，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

常见的占位符有：

%d 整数

%f 浮点数

%s 字符串

%x 十六进制整数

## 10. List\[\] ##

list是一种有序的集合，**可以随时添加和删除其中的元素**。

定义：classmates = \['Michael', 'Bob', 'Tracy'\]

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates)– 1。

最后一个元素：classmates\[-1\]

可以往list中追加元素到末尾：classmates.append('Adam')

可以把元素插入到指定的位置:

>>> classmates.insert(1, 'Jack')
    >>> classmates
    ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

删除list末尾的元素: classmates.pop()

删除指定位置的元素，用pop(i)方法: classmates.pop(1)

替换元素：classmates\[1\] = 'Sarah'

list元素也可以是另一个list，比如：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
    >>> len(s)
    4

要注意s只有4个元素，其中s\[2\]又是一个list，如果拆开写就更容易理解了：

>>> p = ['asp', 'php']
    >>> s = ['python', 'java', p, 'scheme']

要拿到'php'可以写p\[1\]或者s\[2\]\[1\]，因此s可以看成是一个二维数组。

## 11. Tuple() ##

tuple一旦初始化就不能修改,它也没有append()，insert()这样的方法, 因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1,)
    >>> t
    (1,)

## 12. 条件判断 ##

if <条件判断1>:

<执行1>

elif <条件判断2>:

<执行2>

elif <条件判断3>:

<执行3>

else:

<执行4>

If x: 只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

## 13. 循环 ##

Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来，看例子：

names = ['Michael', 'Bob', 'Tracy']
    for name in names:
    print(name)

range(101)就可以生成0-100的整数序列，计算如下：

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)

## 14. Dict\{\} ##

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    >>> d['Michael']
    95

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉。

如果key不存在，dict就会报错。

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

>>> 'Thomas' in d
    False

二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')
    >>> d.get('Thomas', -1)
    -1

注意：返回None的时候Python的交互式命令行不显示结果。

要删除一个key，用pop(key)方法：

>>> d.pop('Bob')
    75
    >>> d
    {'Michael': 95, 'Tracy': 85}

和list比较，dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢；

需要占用大量的内存，内存浪费多。

而list相反：

查找和插入的时间随着元素的增加而增加；

占用空间小，浪费内存很少。

正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

## 15. Set(\[\]) ##

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

重复元素在set中自动被过滤：

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

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)
    >>> s
    {1, 2, 3, 4}
    >>> s.add(4)
    >>> s
    {1, 2, 3, 4}

通过remove(key)方法可以删除元素：

>>> s.remove(4)
    >>> s
    {1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
    >>> s2 = set([2, 3, 4])
    >>> s1 & s2
    {2, 3}
    >>> s1 | s2
    {1, 2, 3, 4}

再议**不可变对象**:

>>> a = 'abc'
    >>> b = a.replace('a', 'A')
    >>> b
    'Abc'
    >>> a
    'abc'

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

[Python]: http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000
[20170316070004074]: /images/20220708/0224735b03bd45e99a039e6610fe7ce4.png
[20170316070241825]: /images/20220708/403005335ac04eda8b55db8bf1b87778.png