Python笔记

数据类型

字符串（str）

使用单引号、双引号或三引号（多行字符串），使用\符号来进行转义。

如果想不对\进行转义，那么可以通过在字符串前面加上前缀r或者R来指定，这种字符串称为自然字符串。

一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。例如，后向引用符可以写成'\\1'或r'\1'。

整数（int）

浮点型（float）

布尔型（bool）

列表（list）

lst = [1,2,3]

列表里面的元素是可变的，可二次赋值

元组（tuple）

tup = (1,2,3,4)

元组里的元素是不可变的，不可二次赋值

字典（dict）

dic = {'a':100,'b':'hello'}

数据类型转换

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

缩进

空白在Python中是重要的。事实上行首的空白是重要的。它称为缩进。在逻辑行首的空白（空 格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组，这意味着同一层次的语句必须有相同的缩进，每一组这样的语句称为一个块。

建议 你在每个缩进层次使用 单个制表符 或 两个或四个空格 ，选择这两种缩进风格之一，更加重要的是，选择一种风格，然后一贯地使用它，即只使用这一种风格。

字符串格式化

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

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

i = 5
print('这次是第%s名' % i)

条件判断

age = input('请输入年龄:')
if age>= 6:
    print('青少年')
elif age>=18:
    print('成年人')
else:
    print('小孩子')

需要注意判断语句后面的冒号：，if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else。

循环

# for循环
a = [1,2,3,4,5]
for x in a:
    print(x)

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

break

# 在循环中，break语句可以提前退出循环
n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

continue

# 在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。
n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

dict和set

dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d['Michael'])    # 95

dict的key必须是不可变对象。

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

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

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

而list相反：

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

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

所以，dict是用空间来换取时间的一种方法。

set

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

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

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

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

函数

定义函数

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回，使用return可以返回多个值，当返回多个值时，最终返回的是一个元组。

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

pass还可以用在其他语句里，比如：

if age >= 18:
    pass

缺少了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

设置默认值

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

**注意：**默认参数必须指向不变对象，如None

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

可变参数

定义可变参数，在参数前面加了一个*号。调用该函数时，可以传入任意个参数，包括0个参数。可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

def add_one(*num):
  for x in num:
    print(x)

关键字参数

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

def add_two(name,age,**other):
  print('name:',name,'age:',age,'other:',other)

a={'city':'beijing','job':'work'}
add_two('tony',12,city=a['city'])    # name: tony age: 12 other: {'cityyy': 'beijing'}

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过other检查。如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):
    print(name, age, city, job)

其他特性

切片

切片操作十分有用。我们先创建一个0-99的数列：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

可以通过切片轻松取出某一段数列。比如前10个数：

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20个数：

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10个数，每两个取一个：

>>> L[:10:2]
[0, 2, 4, 6, 8]

所有数，每5个取一个：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不写，只写[:]就可以原样复制一个list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)