python--11.5

数据类型和变量

1. 字符串：
   转义字符\ ,在字符串内部包含‘’,”“时，用转义字符来标识；
   \n换行
   \t 制表符
   \ 表示 \
   简化： r”,”内部字符串默认不转义
   多行：”’…”’；这个前面也可加r使用

2. 变量：
   命名规则：大小写英文、数字和下划线，且不能用数字开头
   动态语言：变量本身类型不固定。静态语言像java，定义变量时必须制定变量类型
   变量在计算机内存中的表示：a=’abc’,内存中会创建一个abc字符串和一个名为a的变量，并将a指向abc；b = a，内存创建变量b，把b也指向变量a所指向的数据abc；a = ‘xyz’,解释器创建字符串xyz，并把a的指向改为xyz，但是b不会改；print（b）结果是？

3. 常量
   规则：通常用全部大写的变量名来表示，eg. PI表示圆周率π
   除法：第一种：“/”计算结果为浮点数；第二种：“//”地板除，结果为整数；“%”取余

字符串和字符编码

1. str和bytes的互相转换
2. # -- coding: utf-8 --
   保证中文正常编译

格式化字符串%

1. 占位符：%d 整数、%f 浮点数、%s 字符串、%x十六进制整数
2. 格式：‘hello，%s’%‘world’
3. 字符串中含有%—用%%表示一个%

list-列表

1. numbers=[1,3,5,8,9]
   len(numbers) 长度
   numbers[2] 索引，从零开始
   numbers.append(5) 追加元素到末尾
   numbers.insert(1,0) 向索引号为1位置插入元素0
   numbers.pop() 删除list末尾的元素 pop(i)删除指定位置
   numbers[4] = 7 给指定索引位置赋值

tuple-元组（初始化后不能修改）

1. t = (1,3)
2. tuple**指向**不可变，更安全
3. 陷阱:定义只有一个元素的tuple时，要加“,”,否则编译器会认为它是一个数 t = (1,)

条件判断

s = input('birth:')birth = int(s)if birth < 2000:    print('00前')else:    print('00后')

1. 注意if语句的格式，冒号（else后面也要有：）和缩进
2. input返回的数据类型是str，要想和整数比较，必须先把str转换成整数。

循环

1. for…in循环

sum = 0for x in range(101)    sum = sum + xprint(sum)

range(x)函数：生成从0开始小于x的整数

1. while循环

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

1. break–提前结束循环
2. continue–提前结束本轮循环，并开始下一轮循环

n = 0while n < 10:    n = n + 1    if n%2 == 0:        continue    print(n)#会打印出奇数

1. 不要滥用break和continue语句，会造成代码执行逻辑分叉过多，容易出错。通过改写循环条件或者修改循环逻辑，去掉break和continue语句

dictionary（key-value）-字典

d = {'Join':98, 'Bob':78, 'Tracy':83}d['Bob'] = 54   #通过key放入value,多次放入会把前面的值冲掉d.pop('Bob')    #删除key的同时，value也会被删除#避免key不存在而报错，可以用in判断key是否存在；也可以通过dict提供的get方法，如果key不存在，返回none，或者自己制定的value'Thomas' in dd.get('Thomas')   #返回none时交互式命令行不显示结果d.get('Thomas', -1) #如果没有，返回-1

1. dict用空间换取时间，适合需要告诉查找的情况
   dict特点：查找和插入速度快，不会随着key的增多而变慢；需要占用大量内存，内存浪费多。
   list特点：查找和插入的时间随着元素的增加而增加；占用空间少，浪费内存少。

2. dict的key必须是不可变对象，不能是list

set-集合

s = set([1, 2, 3])  #创建时，需要提供一个list作为输入集合s.add(5)    #添加元素s.remove(3) #删除元素

1. set是一组key的集合，但不存储value。key**不能重复**，故set中没有重复的key，重复元素自动过滤。
2. set可以看成数学意义上的无序和无重复元素的集合，故可以做数学意义上的交集&、并集|
3. set和dict唯一区别仅在于没有存储对应的value，同样不可放入可变对象

再议不可变对象

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

a = 'abc'b = a.replace('a','A')  #a只是变量，‘abc’才是字符串对象；a指向的对象的内容才是‘abc’。replace方法没有改变字符串‘abc’的内容，相反会创建一个新的字符串‘Abc’并返回，变量a仍指向原有的字符串‘abc’，但变量b却指向新字符串‘Abc’

函数-function

1. 调用函数：要知道函数名和参数（个数，type）
2. 数据类型转换：int() float() str() bool()
   可以把函数名赋给一个变量，相当于给这个函数取了个“别名”
3. 定义函数：
   参数检查(isinstance())：弥补自定义函数无法识别参数类型不对问题
4. 返回多个值：
   可以返回多个值，但都是假象，其实返回值是一个tuple，多个变量可以同时接收一个tuple，按位置赋给对应的值

def my_abs(x):     if not isinstancee(x, (int,float)):    #只允许整数和浮点数类型        raise TypeError('bad operand type')   #参数检查    if x >= 0:        return x    else:        return -x

函数的参数

1. 位置参数
2. 默认参数–降低函数调用的难度
   陷阱：默认参数必须指向不变对象
3. 可变参数–单星：
   可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple *args
   定义可变参数，只需要在参数前面加*号，调用时就可直接写
   calc(1,4,4,2),calc中接收到的还是一个tuple
   calc(*nums),nums是已有的list或者tuple
   而不是calc((2,3,4,2))

def calc(*numbers):         sum = 0    for n in numbers:        sum = sum + n*n    return sum

1. 关键词参数–双星—扩展函数
   允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict **kw
   有扩展函数的功能，在保证能接收到必要数据的基础上，如果调用者愿意提供更多的参数，我们也能收到

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

person('Bob', 35, city = 'Beijing')     #调用name: Bob age: 35 other: {'city': 'Beijing'}    #结果extra = {'city': 'Beijing', 'job': 'Engineer'}  #先组装一个dictperson('Jack', 24, **extra)     #调用name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

1. 命名关键字参数—限制关键字参数且可以提供默认值
   命名关键字参数必须传入参数名，否则会认为是位置函数，会报错
   如果函数定义中已经有了一个可变参数，后面跟的命名关键字参数就不再需要特殊的分隔符*了

def person(name, age, * , city='Beijing', job): #*后面的参数为命名关键字参数,city有默认值    print(name, age, city, job)

person('Jack', 24, job='Engineer')  #调用Jack 24 Beijing Engineer    #结果

1. 参数组合
   参数定义顺序必须为：必选参数、默认参数、可变参数、命名关键字参数
   任意函数，都可以通过类似func(*args, **kw)的形式调用，无论它的参数是如何定义的（其中args是一个tuple，kw是一个dict）