python基础速记

输入输出

输出
print('hello, world')
//会依次打印每个字符串，遇到逗号“,”会输出一个空格
print('The quick brown fox', 'jumps over', 'the lazy dog')
print('100 + 200 =', 100 + 200)

输入
name = input()
//input可以让你显示一个字符串来提示用户
name = input('please enter your name: ')
print('hello,', name)

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

数据类型和变量

python可以处理任意大小的整数
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。

字符串是以单引号’或双引号"括起来的任意文本
当’是字符串的一部分的时候，使用" 或者使用转义符号“\”
Python还允许用r’‘表示’‘内部的字符串默认不转义
python中字符串的反斜杠问题
Python允许用’’’…’’'的格式表示多行内容

"I'm OK"
'I\'m ok.'

print('''line1
... line2//注意这个...是程序提示符号，交互式环境
... line3''')
line1
line2
line3

在Python中，可以直接用True、False表示布尔值（请注意大小写）
布尔值可以用and、or和not（非）运算

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

变量相关

• 这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错
  也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据

常量相关
在Python中，通常用全部大写的变量名表示常量
但Python根本没有任何机制保证其不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法

底板除 //
只取结果的整数部分

>>> 10 // 3
3

编码

ASCII编码 1个字节
Unicode编码

• 2个字节 各国语言编码需要
• 如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

UTF-8编码

• 本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码
  把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。（节约资源）
• UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作
  

在UTF-8中，一个汉字为什么需要三个字节？
为了区分不同的符号字节

现在计算机系统通用的字符编码工作方式：

• 在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
• 用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件
  
• 浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

python字符

在最新的Python 3版本中，字符串是以Unicode编码的，所以Python的字符串支持多语言

对于单个字符的编码，
ord()获取字符整数表示
chr()把编码转换为对应的字符

>>> ord('A')
65
>>> chr(66)
'B'

Python对bytes类型的数据用带b前缀的单引号或双引号表示：

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

以Unicode表示的str通过encode()方法可以编码为指定的bytes
把bytes变为str，就需要用decode()

>>> 'ABC'.encode('ascii')
b'ABC'
>>> b'ABC'.decode('ascii')
'ABC'

当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码

申明方式
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

另外还需要确保文本编辑器正在使用UTF-8 without BOM编码

len()函数计算的是str的字符数

>>>len('ABC')
3
>>>len('中文')
2

格式化输出

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

有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%

其他格式化方法：format()、f-string

List

list是一种有序的集合，可以随时添加和删除其中的元素。
用索引来访问list中每一个位置的元素，记得索引是从0开始的：
可以用负号获取倒数元素

classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

>>> classmates[0]
'Michael'
>>> classmates[-1]
'Tracy'
>>> classmates[-3]
'Michael'
注意越界的话会弹出错误，正向方向都会弹出

list里面元素数据类型可以不同
>>> L = ['Apple', 123, True]
classmates.append('Adam')//往List中追加元素到末尾
classmates.insert(1, 'Jack')//把元素插入到1的位置
classmates.pop()//删除list末尾元素
classmates.pop(1)//删除指定位置的元素

//里面的数据类型可以不同
>>> L = ['Apple', 123, True]

//list元素也可以是另一个list
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

//空LIst
>>> L = []
>>> len(L)
0

tuple

tuple一旦初始化就不能修改，不可变主要是说tuple的每个元素，指向永远不变。

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

//定义一个只有一个元素的tuple,注意这个逗号，因为括号()既可以表示tuple，又可以表示数学公式中的
小括号，少了的话就按括号处理，编程赋值操作
>>> t = (1,)
>>> t
1

//定义空的tuple()
>>> t = ()
>>> t
()

//注意这个可变tuple，所以要理解不变的含义
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

break：提前结束循环

continue：跳过当前的这次循环，直接开始下一次循环。

条件判断

//注意不要忘记写冒号
//条件判断从上向下匹配，当满足条件时执行对应的块内语句，后续的elif和else都不再执行。
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

循环

for

for x in ...

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

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

while
注意冒号

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

dict

就是字典
使用键-值（key-value）存储，具有极快的查找速度。
占用大量内存，用空间换时间，映射出去的值不可控
dict的key必须是不可变对象

• 哈希表，映射的时候肯定要数据长度固定，可变的话就乱套了

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

数据放入dict的方法，除了初始化时指定外，还可以通过key放入

>>> d['Adam'] = 67
>>> d['Adam']
67

如果不存在会报错，所以判断key是否存在的方法如下

>>> 'Thomas' in d
False

//如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

删除dict

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

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
重复元素在set中会被自动过滤

要创建一个set，需要提供一个list作为输入集合：
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元
素，显示的顺序也不表示set是有序的。

//添加元素
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

//删除元素
>>> s.remove(4)
>>> s
{1, 2, 3}

//两个set可以做数学意义上的交集、并集等操作：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

标题再议不可变对象

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a
仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：

函数

#定义
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
#无ruturn 则返回NONE
#参 数检查，用isinstance()函数
如果传入错误的参数类型，函数就可以抛出一个错误

#空函数定义
def nop():
    pass
#pass主要是起占位符作用，啥也不干
缺少会报错

#函数可以返回多个值，多个值返回其实是返回一个tuple
import math
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

函数的参数

def enroll(name, gender, age=6, city='Beijing'):

enroll('Sarah', 'F')#使用了默认参数
enroll('Bob', 'M', 7)#改参数
enroll('Adam', 'M', city='Tianjin')#跳着改

#定义默认参数要牢记一点：默认参数必须指向不变对象！

可变参数
允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
    
#调用方式
>>> calc(1, 3, 5, 7)
84

#已经有一个list或者tuple，要调用一个可变参数
>>> nums = [1, 2, 3]
>>> calc(*nums)
14

关键字参数

关键字参数可以扩展函数的功能
允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Michael', 30)
name: Michael age: 30 other: {}

>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

命名关键字参数必须传入参数名
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
#**表示全部调用

#检查关键字参数
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)

参数组合
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。