Python（一）

一、前言

一、python的应用

1. 网络应用：网站、后台服务
2. 工具：脚本
3. 包装其他语言开发的工具

二、优缺点

1. 提供了完善的基础代码库，覆盖网络、文件、GUI、数据库、文本等大量内容，被形象的称为”内置电池“
2. 大量第三方库
3. 优雅、明确、简单
4. 语法简单，使用缩进式
5. 运行速度慢（解释性语言）
6. 代码不能加密（大家都那么忙，哪有闲工夫破解你的烂代码）

三、简介

1. python以#开头的语句是注释
2. 采取缩进式，惯例为四个空格的缩进
3. 冒号:结尾时，缩进的语句是为代码块
4. 大小写敏感

二、Python基础

一、输入输出

1. 输出print()

   print('hello,world')
   print('My name is','nusqx')
   # print()会依次打印每个字符串，遇到逗号','会输出一个空格 My name is nusqx
   print('10+20=',10+20) # 10+20=30

2. 输入input()，返回的数据类型是str

   name = input() # nusqx
   print(name) # nusqx
   # 输入时加提示信息
   name = input('please enter your name: ')
   print('hello,',name)

二、数据类型和变量

1. 在python中能直接处理的数据类型

   • 整数，与数学中的写法一样

     0x前缀和0-9，a-f表示十六进制

     对于很大的数，数字中间可以用_分割，100_000_000

   • 浮点数，小数，科学计数法

     1.23*10-5即1.23e-5

   • 字符串，用''或""表示

     字符串内部包含引号字符，用转义字符\表示，如'I\'m OK'

     转义字符可以转义很多字符，如\n表示换行符，\t表示制表符，\\表示\

     如果字符串包含很多字符需要转义，可以用r''表示''内部的字符串默认不转义

     print("I'm NUSQX")
     print(r'\\\t\\\\')

     如果字符串内部有很多换行，用\n写在一行不好阅读，可以用’’’…’’’的格式

     print('''line1
     ... line2
     ... line3''') #上面是在交互式命令行内输入，在输入多行内容时，提示符由>>>变为...
     print('''line1
     line2
     line3''')
     line1
     line2
     line3
     #接着上一行输入，注意...是提示符，不是代码的一部分

   • 布尔值，True和False

     布尔值可以用and、or、not运算（与、或、非）

   • 空值None

   • Python还提供了列表、字典等多种数据类型

2. 变量，变量名必须是大小写英文字母、数字、下划线的组合，数字不能开头

3. Python是动态语言，变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言。

4. 常量通常用全部大写的变量名表示常量

5. python中有两种除法，

   • 一种/，计算结果是浮点数，即使是两个整数恰好整除，结果仍是浮点数
   • 另一种//地板除，只取结果的整数部分

6. 余数运算%

7. python中type()函数可以查看类型

三、字符串和编码

1. Unicode把所有语言都统一到一套编码里，就不会再有乱码问题了。

2. ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。

3. 如果统一成Unicode编码，乱码问题从此消失了。但是，如果写的文本基本上全部是英文，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

4. 把Unicode编码转化为“可变长编码”的UTF-8编码，UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。

5. 计算机系统通用的字符编码工作方式：在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：

   

6. 浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

   

7. 对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

   ord('A') # 65
   ord('a') # 97
   chr(66) # 'B'
   chr(0x4e2d) # '中'
   '\u4e2d' # '中'
   chr(25991) '文'

8. 计算字符串长度len()函数

   a = 'nusqx'
   len(a)
   len(SQX)

9. 格式化输出%

   常见的占位符有：有几个%?占位符，后面就跟几个变量或者值，顺序要对应。如果只有一个%?，括号可以省略。

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

   其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数。

10. 字符串里面的%是一个普通字符，这个时候就需要转义，用%%来表示一个%

11. format()方法格式化字符串，用传入的参数依次替换字符串内的占位符{0}、{1}…

12. f-string使用以f开头的字符串，称之为f-string，它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换

    'hello, %s' % 'nusqx'
    'Hi, %s, you have %d apples.' % ('nusqx', 6)
    print('%2d-%02d' % (3,1)) # 3.1000
    '%.4f'%3.1415926 # 3.1416
    'growth rate: %d %%' % 7 # 7 %
    'hello,{0},中奖{1}百万'.format('nusqx',500)
    r = 2.5
    s = 3.14 * r ** 2
    print(f'The area of a circle with radius {r} is {s:.2f}')

四、使用列表list和元组tuple

1. python内置列表：list，一种有序的集合，可以随时添加和删除其中元素

2. len()函数可以获取list元素的个数

3. 用索引访问list中的每一个位置的元素，0开始，不可越界；如果访问最后一个，也可用-1，以此类推

4. 往list中追加元素到末尾append()

5. 把元素插入到指定位置insert()

6. 删除list末尾元素pop()

7. 删除指定位置元素pop(i)

8. 替换某个元素，可以直接赋值给对应的索引位置

9. list中元素数据类型可以不同

10. list元素可以是另一个list，访问list中list，可以看作二维数组，类似的还有三维、四维

11. list中一个元素也没有，就是空list，长度为0

    classmates = ['Bob','Tom','Jack','Rose']
    len(classmates) # 4
    classmates[1] # 'Tom'
    classmates[-3] # 'Tom'
    classmates.append('SQX') # ['Bob','Tom','Jack','Rose','SQX']
    classmates.insert(1,'John') # ['Bob', 'John', 'Tom', 'Jack', 'Rose', 'SQX']
    classmates.pop() # ['Bob', 'John', 'Tom', 'Jack', 'Rose']
    classmates.pop(-1) # ['Bob', 'John', 'Tom', 'Jack']
    classmates[0] = 'Nick' # ['Nick', 'John', 'Tom', 'Jack']
    project = ['java','php','python','c']
    stu = ['Jack', 253.6, 176, [15, 20, 'B'], 'A']
    stu[3] # [15, 20, 'B']
    stu[3][2] # 'B'
    L = []
    len(L) # 0

12. 另一种有序列表叫元组，tuple一旦被初始化就不能修改，代码更加安全

13. tuple的陷阱：当定义一个tuple时，tuple的元素必须被确定下来

14. 元组不能像列表一样增加、删除等，访问方法一样

15. 要定义一个只有1个元素的tuple，如果是数字，防止与数学公式中括号产生歧义，必须加一个逗号,

    tup = (1,2,'a')
    tup[0] # 1
    tup[-3] # 1
    t = (1,) # (1,)
    len(tup) # 3
    tt = ('a','b',['A','B'])
    tt[2][0] # 'A'
    tt[2][0] = 'X'
    t[2][1] = 'Y'
    # ('a', 'b', ['X', 'Y'])

16. tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。要创建一个内容也不变的tuple，就必须保证tuple的每一个元素本身也不能变。

五、条件判断

1. if…else / if… elif…else （注意缩进和冒号）

   if <条件判断1>:
       <执行1>
   elif <条件判断2>:
       <执行2>
   elif <条件判断3>:
       <执行3>
   else:
       <执行4>

2. if判断条件可以简写，只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

   if x:
   	print('True')

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

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

六、循环

1. for x in ...

   project = ['java','php','python','c','go']
   for x in project:
       print(x)
   sum = 0
   for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :
       sum = sum + i
   print(sum)

   如果计算1-100的累加和，上述方法有点困难，Python提供一个range()函数，生成一个整数序列，再通过list()函数转换为list

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

2. while

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

3. break提前跳出循环

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

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

   n = 0
   while n < 10:
       n = n + 1
       if n % 2 == 0:
           continue
       print(n)

5. python执行死循环，按Ctrl+C推出程序

七、使用dict和set

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

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

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

4. key不存在，dict就会报错，可以通过in判断key是否存在，或者通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value

5. 删除一个key，用pop(key)方法，对应的value也会从dict中删除

6. dict内部存放的顺序和key放入的顺序是没有关系

   d = {'nusqx': 175, 'Bob': 172, 'Nice': 162}
   d['nusqx']
   d['Jack'] = 167
   d['Jack'] = 160
   'sqx' in d # False
   d.get('nusqx') #175
   d.get('pei') #
   d.get('Nice', 163) # 162
   d.pop('Nice') # 162
   # {'nusqx': 175, 'Bob': 172, 'Jack': 160}

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

   • 查找和插入的速度极快，不会随着key的增加而变慢；
   • 需要占用大量的内存，内存浪费多

   list相反：

   • 查找和插入的时间随着元素的增加而增加；
   • 占用空间小，浪费内存很少

   dict是用空间来换取时间的一种方法

8. dict的key必须是不可变对象

9. 通过key计算位置的算法称为哈希算法（Hash），要保证hash的正确性，作为key的对象就不能变

10. 集合set也是一组key的集合，但不存储value

11. 要创建一个set，需要提供一个list作为输入集合

12. 显示的顺序也不表示set是有序的，重复元素在set中自动被过滤

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

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

15. 两个set可以做数学意义上的交集、并集等操作

16. set和dict的唯一区别仅在于没有存储对应的value，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”

    s = set([1, 2, 3])
    s = set([1, 1, 2, 2, 3, 3])
    s.add(4)
    s.remove(1)
    s1 = set([1,2,4])
    s1 & s
    s1 | s

17. 不可变对象，str是不变对象，而list是可变对象

    a = ['c', 'b', 'a']
    a.sort()
    #a: ['a', 'b', 'c']
    a = 'abc'
    a.replace('a', 'A') # 'Abc'
    a # 'abc'

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

    #定义元组
    t1 = (1,2,3)   #内容不变
    t2 = (1,[2,3]) #指向不变，但内容可以发生改变
    
    #以dict为例
    d1 = {t1:1}
    out: {(1, 2, 3): 1}   # 创建了key为元组t1，value为1的字典
    d2 = {t2:2}
    TypeError: unhashable type: 'list'  # 报错：list是不可使用哈希算法的类型。
    #set
    s1 = set(t1) # {1, 2, 3}
    s2 = set(t2) #TypeError: unhashable type: 'list'

    要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：虽然t2作为tuple是不可变对象，但是这里的不可变是指“指向不变”，内容是可以发生改变的。这里为了保证Hash算法，key应同时满足内容不变和指向不变。t1是内容和指向都不变的元组，因此可以作为dict的key，而t2则不可以。

保留字