python 语法基础

Python 基础语法

一, 预备知识

编译型语言与解释型语言

• 编译器
  • 计算机只能识别机器语言，将高级语言翻译为机器语言的工具
• 解释器
  • 编译与解释再翻译源代码的时间点不同
• 编译型语言工作流程
  • 源代码 - > 编译器翻译 -> 可执行文件 -> 操作系统执行
• 解释型语言工作流程
  • 源代码 -> 边解释边运行每一句源代码 -> 操作系统执行

python 语言的优缺点

• 优点
  • 丰富的库和良好的扩展性
  • 跨平台
• 缺点
  • 运行速度较慢

Python解释器

• Python是一个名为解释器的软件包，让其他程序运作起来的程序，即代码与机器的硬件之间的软件逻辑层
  • Python解释器读取程序，并按照其中的命令执行，得出结果
• 字节码编译：源码编译成字节码：将每一条源码翻译成字节码指令，提高执行效，保存为.pyc文件。如果源码没有改变（根据两者文件的时间戳），则程序下次执行时无需重编译，可以直接使用字节码文件
• Python虚拟机
  • 字节码会发送到PVM上执行
  • PVM就是一个一个运行字节码指令的循环，一个接着一个执行。
• python代码只有运行时，无需编译阶段，可以动态修改

简单执行python程序

• windows 命令行运行python文件
  • python filename.py

IDE - pycharm

• pycharm快捷操作：https://www.pycharm.com.cn/t/20

１.编辑类PyCharm快捷键
Ctrl + 鼠标 跳转到（变量、方法、类）声明
Ctrl + / 行注释
Ctrl + Shift + / 块注释
Ctrl + Shift + ]/[ 选定代码块结束、开始
Alt + ／ 自动完成（联想）
Ctrl + Alt + L 代码格式化
Ctrl + Alt + O 优化导入
Ctrl + Alt + I 自动缩进
Tab / Shift + Tab 缩进、不缩进当前行
Ctrl + D 复制选定的区域或行
Ctrl + Y 删除选定的行
２.运行类PyCharm快捷键
Shift + F10 运行
Shift + F9 调试
３.调试类快捷键
F8 跳过
F7 进入
Shift + F8 退出
Alt + F9 运行游标
Alt + F8 验证表达式
Ctrl + Alt + F8 快速验证表达式
F9 恢复程序
Ctrl + F8 断点开关
Ctrl + Shift + F8 查看断点
４.导航类快捷键
Ctrl + N 跳转到类
Ctrl + Shift + N 跳转到文件
Alt + Right/Left 跳转到下一个、前一个编辑的选项卡
F12 回到先前的工具窗口
Esc 从工具窗口回到编辑窗口
Shift + Esc 隐藏运行的、最近运行的窗口
Ctrl + Shift + F4 关闭主动运行的选项卡
Ctrl + G 查看当前行号、字符号
Ctrl + E 当前文件弹出
Ctrl+Alt+Left/Right 后退、前进
Ctrl+Shift+Backspace 导航到最近编辑区域
Alt + F1 查找当前文件或标识
Ctrl+B / Ctrl+Click 跳转到声明
Ctrl + Alt + B 跳转到实现
Ctrl + Shift + I查看快速定义
Ctrl + Shift + B跳转到类型声明
Ctrl + U跳转到父方法、父类
Alt + Up/Down跳转到上一个、下一个方法
Ctrl + ]/[跳转到代码块结束、开始
Ctrl + F12弹出文件结构
Ctrl + H类型层次结构
Ctrl + Shift + H方法层次结构
Ctrl + Alt + H调用层次结构
F2 / Shift + F2下一条、前一条高亮的错误
F4 / Ctrl + Enter编辑资源、查看资源
Alt + Home显示导航条F11书签开关
Ctrl + Shift + F11书签助记开关
Ctrl + #[0-9]跳转到标识的书签
Shift + F11显示书签
５.查找／替换类快捷键
F3 下一个
Shift + F3 前一个
Ctrl + R 替换
Ctrl + Shift + F 全局查找
Ctrl + Shift + R 全局替换
Alt + F7/Ctrl + F7文件中查询用法
Ctrl + Shift + F7文件中用法高亮显示
Ctrl + Alt + F7显示用法
６.重构类PyCharm快捷键
Alt + Delete安全删除
Shift + F6重命名
Ctrl + F6更改签名
Ctrl + Alt + N内联
Ctrl + Alt + M提取方法
Ctrl + Alt + V提取属性
Ctrl + Alt + F提取字段
Ctrl + Alt + C提取常量
Ctrl + Alt + P提取参数

命名规则

• 只能包含字母、数字和下划线，且只能字母或下划线开头， 名字不能与关键字重合

• 包、模块

  • 简短，全部小写，下划线分割

• 类名

  • 采用驼峰命名， 首字母大写

• 函数，方法

  • 全部小写，下划线分割
  • 私有函数，下划线开头

• 常量，全局变量

  • 全部大写，下划线分割

• 变量

  • 全部小写，下划线分割
  • 私有类成员，下划线开头

字符串和编码

• 计算机中只能处理数字，如果要处理文本等数据，需要先将文本转为数字才能处理。
• 一个字节byte为8个比特bit

不同的编码

• ASCII编码
  • 只有127个字符被编码到计算机中（大小写字符，数字，部分符号
  • 编码是1个字节
• GB2312编码
  • 处理中文一个字节是不够的，至少需要两个字节，而且要兼容ASCII编码（不冲突），中国制定了GB2312编码，实现了中文编码
• Unicode编码
  • 由于不同国家有不同的语言，产生不同的编码规则，不同编码的数据转换会乱码，unicode应运而生，将所有语言统一到一套编码中，解决乱码问题
  • 编码最常用的是2个字节表示一个字符（偏僻字符可能用到4个字符）
  • 汉字超出了ASCII编码范围
  • 把ASCII编码转为Unicode编码，只需要前面补一个字节的0就可以
    • A的Unicode码：00000000 01000001
  • 缺点
    • 使用Unicode编码比ASCII编码多一倍的存储空间，在存储和传输过程中就不划算
• UTF-8编码
  • 由于Unicode的缺点，为了节约存储和传输成本，出现了可变长编码，即UTF-8编码
  • UTF-8将一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母编码为1个字节，汉字通常为3个字节，只用很少生僻字符才被编码为4-6个字节，如果传输的文本包含大量英文字母，用utf-8编码会节省成本。

计算机通用的字符编码工作方式

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

Python的字符串

1. 原理

• python的出现要早于unicode编码，早期的python只支持ASCII编码，普通的字符串'ABC'在python内部都是ASCII编码的，python提供函数将字母和数字转换
  • 字母转数字
    • ord('A') -> 65
    • chr(65) -> 'A'
• python后续添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示
  • print u'中文' -> 中文
  • u'中' -> u'\u4e2d
    • \u后面是十六进制的Unicode编码
• ASCII字符串也可以看作UTF-8的字符串，而u'xxx'只能是Unicode编码
  • 把u'xxx'转换为UTF-8编码的'xxx'用encode('utf-8')
    • u'ABC'.encode('utf-8') -> 'ABC'
    • 英文字符转换后表示的utf-8的值和Unicode的值相同(但是存储空间不同),中文字符的一个Unicode字符将变成3个UTF-8字符
      • u'中文'.encode('utf-8') -> \xe4\xb8\xad\xe6\x96\x87
  • UTF-8编码字符串转为Unicode用 decode('utf-8')
    • 'abc'.decode('utf-8') -> u'abc'
    • '\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8') ->中文
  • UTF-8编码字符串转为Unicode用 unicode()函数
    • unicode('xxx','utf-8')

2. python文件头添加注释，处理非ASCII字符

# -*- coding: utf-8 -*-

• 保存文件时的编码流程
  • python源代码是以文本文件的方式保存，如果源代码中含有中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码，将编码得到的二进制数据保存到文件中
• 当执行python文件时，解释器所做的事情
  • 1. python解释器程序会把源码文件的二进制数据读入内存；
  • 2. python解释器会把读入内存的二进制数据翻译为python代码；
  • 3. python解释器会执行由源码文件二进制内容翻译得到的python代码。
• 第2步中，当python解释器读取二进制代码，我们需要通过 “ # -- coding: utf-8 --” 告诉解释器按照UTF-8编码读取，这就是解码过程
  • 注释是为了告诉python解释器，按照utf-8编码读取源代码，否则源代码中的中文输出就可能出现乱码，而解释器则通过正则表达式去匹配得到编码格式

3. 默认编码格式

• python2默认编码方式为ASCII

• python3默认编码方式为UTF-8

• 可以通过一下语句查看

  • import sys
    print(sys.getdefaultencoding())
    

二，Python语法基础

注释

单行注释 以 # 号开头
多行注释
"""
xxxx...
"""

数据类型

• 查看变量的数据类型
  • type(变量名)

• numbers类型
  • int
  • float
  • complex
• bool 类型
  • True
  • False
• string字符串
  • 可以用单引号或者双引号表示字符串
• 空值
  • None
• list
  • python内置的一种列表，有序的集合，可以随时添加和删除其中的元素
• Tuple
  • 元组
• Dictionary
  • 字典
• Set
  • 集合

变量

• 变量
  • 不需要数据类型
  • 变量名变量遵循驼峰规则
  • 可以反复赋值，还可以赋值不同数据类型的变量（动态语言特性）
• 当创建变量 s = 'abc'时，python解释器会干两件事
  • 先在内存中创建一个'abc'的字符串
  • 然后在内存中创建一个名为a的变量，并将它指向'abc'
• 常量
  • python中的常量其实还是一个变量，语言上没有机制保证其不变
  • 常量名全部都是大写

逻辑运算符与取反

# 逻辑运算符(与或非） and  or  not

* 非
  * not

基本的输入输出

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

• print 函数的语法

  • objects
    • 要输出的对象，多个对象用 逗号分隔开
  • sep
    • 多个对象之间的分隔符，不指定则默认是空格
  • end
    • 结尾符号，默认是换行
  • file
    • 要写入的文件对象
  • flush
    • 缓存流是否强制刷新

• 基本输入 - inpu获取用户的控制台输入

name = input("用户名：")
pwd = input("密码：")
print("name = ", name)
print("pwd = ", pwd)

占位符填充的方式

• python格式化方式与c语言一致，用%实现
• 整数
  • %o —— oct 八进制
  • %d —— dec 十进制
  • %x —— hex 十六进制
• 浮点数
  • %f ——保留小数点后面六位有效数字
  • %.3f，保留3位小数位
  • %e ——保留小数点后面六位有效数字，指数形式输出
  • %.3e，保留3位小数位，使用科学计数法
  • %g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
  • %.3g，保留3位有效数字，使用小数或科学计数法
• 字符
  • %s表示字符串
  • %10s——右对齐，占位符10位
  • %-10s——左对齐，占位符10位
  • %.2s——截取2位字符串
  • %10.2s——10位占位符，截取两位字符串
• %x表示十六进制整数
• 有几个%,后面就会跟几个变量或者值，顺序要对应好，只有一个%则括号可以省略

'hello, %s' % 'world' -> 'hello, world'

'hi,%s, you have $%d.' % ('binge', 100) -> hi,binge, you have $100.

• 格式化整数和浮点数还可以指定是否补0和整数大小的位数

'%2d-%02d' % (3, 1) -> ' 3-01'

'%.2f' % 3.1415926 -> '3.14'

• 对于Unicode字符串，要保证替换的字符串也是Unicode字符串
  • u'hi,%s' % u'binge' -> u'hi binge'
• 字符串中%是个普通字符，需要用%转义 %% -> %

数据运算处理

• 除法
  • 得到浮点数:
    • 10 / 3
  • 整除
    • 10 // 3
• 取模运算 - 取余数
  • 10 % 3
• 乘法幂运算
  • 10 * 3
  • 10 的三次方 10 ** 3
• 向上取整
  • round(number)
  • math.ceil(num) ： 需要 import math

string 字符串

• 当程序中包含中文字符时，需要在代码文件头部加入一行代码

  • #-*-coding: UTF-8 -*-
    

  • 作用

    • 在python2环境中编写python代码时，python interpret如何解释字符串的编码

  • 原理

    • python2默认的编码格式是ASCII格式，如果不加这句代码，ASCII无法正常解析中文字符，导致程序报错
    • python3默认的编码格式是utf-8格式，则可以不写这句话，但为了程序更好的移植性，还是加上。

  • 使用编辑器进行编码时，需要是设置py文件的存储格式为utf-8

• 类型：

  • 单行字符串： ' '
  • 多行字符串：''' '''

• 单双引号无差别，要显示引号要转义\

print('binge\'hobby is football')
print('binge:"hello world"')

• 索引
  • 正向 0 1 2
  • 反向 -1 -2 -3

1. 字符串的切片

• 规则
  • 左闭右开 (包含左值，不包含右值)
• 格式
  • string[start : end]
  • string[start, stop, step]
    • 指的是从 start 索引处的字符开始，每 step 个距离获取一个字符，直至 end 索引出的字符。step 默认值为 1，当省略该值时，最后一个冒号也可以省略常用的切片功能

# 指定位置到结尾
string[index:] 

#开头到指定位置
string[:index]
#浅复制(指针复制)
string1[:]

#每隔3个字符取出一个字符
string[]

# 反转
str[::-1]

2. 字符串的不可变性与修改

• 字符串创建后无法修改，只能建立一个新的字符串进行重新赋值，因为python在运行过程中会清理对象

s = "abc"
s[0] = 'f'
# 报错 TypeError ：'str' object does not support item assignment

# 正确操作
s = 'f' + s[1:]

# replace函数也是生成新的字符串对象

3. 字符串的拼接

• 直接将两个字符串 + ，拼接成新字符串
• join 函数 将 list，tuple 的所有元素拼接为字符串
  • '拼接字符'.join(listName)

• list = ['www','baidu', 'com']
  
  print('.'.join(list))
  
  # 结果
  www.baidu.com
  

4. 字符串的大小写转换

• 判断是否都是大写字符
  • str.isupper()
• 小写转大写
  • str.upper()
• 大写转小写
  • str.lower()
• 首字符大写
  • str.title()

5. 字符串的检索

统计字符串中子串的出现次数

• count（substr，start，end）

str = "xiaozhuzhu"
print(str.count("zhu"))
print(str.count("zhu", 0, 2))
print (str.count("zhu", 5))

# 结果
2
0
1

字符串中查找子串

• find(substr, start, end)
  • 成功则返回某个字符或者字符串在指定串中第一次出现的索引
  • 失败则返回-1
• 从后往前找
  • rfind()

str = "xiaozhuzhu"

print(str.find("zhuzhu"))
print(str.find("fand"))

• 查找字符串中是否含有字串 2
  • index(substr, start, end)函数
    • 功能与find 类似，但查找失败时会报出异常
• 查找字符串中是否含有字串 3
  • substr in str
    • 成功返回True，否则返回False

字符串是否以指定的子串开头

• startswith（substr, start, end)
• 是则返回 True，否则返回False

字符串是否以指定的子串结尾

• endswith（substr, start, stop)

• 测试字符串中的内容

  • str.isalpha()
    • 只有字母组成
  • str,isdigit()
    • 只有数字组成

6. 字符串的分割

字符串的分割

• split() - 通过指定的分割符对字符串进行分割

  • 格式
    • str.split("分隔符", 分割次数)
    • 不加参数，任意以空白字符对整个字符串进行分割
    • 空白字符指 （空格，\n，\t，\r）
  • 返回值
    • 返回一个 list

• splitlines()

  • 与split 类似，但默认分割字符不同
    • 以行界定符分割（\r, \n, \r\n)

• partition()

  • 格式
    • str.partition(string_pre_str, str, str_post_str)
    • 从str出现的第一个位置，将字符串分为3个元素的元组（前面，str, 后面）

字符串的修剪

• strip(chars)
  • 移除字符串头尾指定的字符系列（默认为空格或者换行符）
• lstrip()
  • 只移除左侧
• rstrip()
  • 只移除右侧

7 字符串的替换

• str.replace(old, new[, max])
  
  

• 参数
  • old -- 将被替换的子字符串。
  • new -- 新字符串，用于替换old子字符串。
  • max -- 可选字符串, 替换不超过 max 次

8. 字符串的格式化输出

替换符号%

• % 方式
  • 字符串 % 元组

num = 1
str = "xiao zhu zhu"
print("the %d is %s" % (num,str))

f - format 格式

• 字符串.format(xxx,xxx,xxx)

num = 1
str = "xiao zhu zhu"
print("the {} is {}".format(num,str))

# 或者指定索引
print("the {0} is {1}".format(num,str))

# 或者指定参数
print("the {num} is {str}".format(num=num,str=str))

f-string 格式

• python 3.6 后支持

• 用f 或者 F 修饰符引领的字符串，以{}标明被替换的字段

• {} 内部可以使用函数或者进行计算

• 注意事项

  • 大括号内所用的引号不能与大括号外的边界符冲突，
    • 内外可以是不同单引号和双引号组合
    • 或者使用三个引号，那么内部就可以使用其他引号
  • 大括号内部不能使用转义字符
  • 大括号内需要显示大括号，则输入双大括号

• 也可以用于输入多行字符串，换行时用 \ 连接即可

• f-string 自定义格式

  • 【大熊课堂】Python零基础入门必看动画课：Python基础教程+最新Python实用案例_哔哩哔哩_bilibili

num = 1
str = "xiao zhu zhu"
print(f'the {num} is {str}')

• 几种方式的对比使用

# 打印九九乘法表

# % 方式
for i in range(1, 10):
    for j in range(1, i+1):
        print ('%s*%s=%s' % (j, i, j*i), end = ' ')
    print()
    
# format 方式
for i in range(1, 10):
    for j in range(1, i+1):
        print ('{0}*{1}={2}'.format(j, i, j*i), end = ' ')
    print()
    
# f-string 方式
for i in range(1, 10):
    for j in range(1, i+1):
        print (f'{j}*{i}={j*i}', end = ' ')
    print()

9. 字符串匹配 （正则)

import re
match = re.match('Hello[ \t]*(.*)world',"Hello  Python   world")
match.group(1) -> "Python  "

# 目的：以"Hello,"开始，后续有多个空格，接着有任意字符（将其保存到匹配的group中）然后将以world结尾

• 核心类型中，数字，字符串，元组都是不可变的，不可变类型的变量作为参数，则是值传递

list 列表

• 内置的一种有序集合，可以随时增删元素
  • 元素可重复，类型可不同

1. 创建列表

• 直接创建
  • 空集合list = []
• 直接赋值
  • classmates = [ 'binge', 'zhuzhu', 'dongdong']
  • 可以支持将其他类型的元素转为列表

2. 列表元素访问

下标访问

• 支持下标访问，索引从0开始，最后一个元素是len(listname)-1
  • 负下标就是从后往前访问

判断元素是否在list中

• in
• not in

获取元素在list中的第一次出现的索引

• index
  • list.index(target)
• 不存在则报错

获取list中元素出现个数

• count
  • list.count(target)

3. 列表切片(类似于string字符串)

• list[start, stop]
  • 索引从start开始但不包含stop
• 从第一个元素到最后
  • list[1:]

4. 列表增删

添加元素到末尾

• list.append('xixi')

删除集合末尾元素

• list.pop()

向指定位置插入元素

• list.insert(1,'xixi')
  • 插入后，xixi在集合的第二个元素的位置

删除指定位置的元素

• list.pop(index)
• list.remove(obj)
  • obj -- 列表中要移除的对象

替换某个位置的元素

• list[index] = newone

5. List拼接

• 最简单的方式

6. 列表排序

• 正向排序
  • listName.sort()
• 反向排序
  • listName.reverse()
• 边界检查
  • 下标操作需要注意索引越界异常

7. list嵌套与解析

• list集合可以嵌套使用，像多维数组
• 列表解析操作

 M = [  [1,2,3],
        [4,5,6],
        [7,8,9] ]

# 获取矩阵第二列
row2 = [row[1] for row in M]
    -> [4,5,6]

# 对矩阵第二列每个元素+1
[row[1] + 1 for row im M]
    ->[3,6,9]

# 就结果集中元素进行筛选操作
[row[1] for row in M if row[1] % 2 == 0]
    ->[2,8]

#  获取i行i列的元素的结果集
[M[i][i] for i in [0,1,2]]

tuple元组

• 另一种有序集合，与list不同，tuple一旦初始化就不能再修改
• 元组的功能（为什么要有元组）
  • 如果将list作为参数传递，可以在任意位置修改列表原来的值（引用传递）
  • 使用元组则不能，实现了完整的约束

def test(l):
    l[1] = 8
    print("l1 = ", l)

if __name__ == '__main__':
    l = [1, 2, 3, 4, 5]
    t = (1, 2, 3, 4, 5)
    test(l,t)
    print("l2 = ", l)
    
# 运行结果

l1 =  [1, 8, 3, 4, 5]
l2 =  [1, 8, 3, 4, 5]

1. 元组创建

• 创建空的元组
  • t = ()
• 创建多个元素的元组
  • classmates = ('binge','zhuzhu','dongdong')
• 陷阱：定义只有一个元素的tuple
  • t = (1)
    • 结果 t 不是tuple，而是一个整型1，按照数学公式的括号处理
  • 需要定义一个元素的tuple
    • t = (1,)
• 如果tuple的元素是list,为什么list中的元素可变
  • 因为tuple中记录的是list变量其实是list的地址，指向list的内存，这个过程中tuple的元素没有改变，改变的只是tuple的list变量所执行的内存地址的值，它的指向没有改变（就好像是c语言中的指针）

2. 类似于列表的功能

• 支持索引
• 支持切片
• index ,count ,in not in

# 元组 不可变
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'x'
t[2][1] = 'y'
print(t)

结果为  ('a', 'b', ['x', 'y'])

(1,2) + (3,4) -> (1,2,3,4)
(1,2) * 2 -> (1,2,1,2)

字典 dict

• python内置了字典dict（即dictionary），在其他语言中称为map,即键值对
• dict的原理
  • 查字典是，先在字典的索引表中查这个字对应的页码，再根据页码找到这个字，存储的时候也会先根据key值计算value存储的位置，再存储
• key值不可变，但是value可覆盖，dict的存放位置是哈希表形式，与key的插入顺序无关
  • 除了list、dict、set和内部至少带有上述三种类型之一的tuple之外，其余的对象都能当key
  • 一个对象能不能作为字典的key，就取决于其有没有哈希方法

1. 创建字典

• 创建空字典
  • D = {}
  • D = dict()
• D =
• D = dict(name= "Bob", age = 42)

2. 用列表赋值

• 以list中的元素作为键，值为None
  • dict.forkeys([])
• 以键值list构造
  • dict(zip(keyslist, valslist))

3. 查询和取值

获取字典的键的集合并通过键遍历字典

• D.keys()
• 3.0后需要对list(D.keys())才能使用，因为它返回的是迭代器

# 通过key值遍历，如字典 dict1
 for key in dict1:
	print(key+':'+a[key])
	
# 还可以对键进行排序字母
for key in sorted(dict1):
	print(key+':'+a[key])
	
# .keys( ) + 索引进行迭代
for key in dict1.keys():
	print(key+':'+dict1[key])

获取值的集合

• D.values()

# 遍历字典 value
for value in a.values():
	print(value)

将一个字典以列表的形式返回，元素是键值对的元组

• D.items()
  • 返回一个 dict_items的对象
• list(D.items())
  • 获取一个list形式的items

# 遍历字典 键值对
for key,value in dict1.items():
	print(key, ": ", value)

字典深拷贝，获取副本

• D.copy()

获取某一个元素

• D.get(key, default)
  • 如果key,不存在则返回none，或者自己指定的value,x可以省略

dict下标访问

• d['binge'] -> 98
  • key不存在则会报错
  • 可以通过 in 进行判断
    • 'binge' in d

字典合并

• D.update(D2)

4. 根据键删除条目

• del D[key]

• 删除一个key,返回其对应的值
  • d.pop('binge')

5. dict 与 list 对比

• dict的特点
  • 查找和插入的速度快，不会随着key增加而增加
  • 占用内存多
• list的特点
  • 查找和插入的时间随着元素增加而增加
  • 占用内存少
• dict应用于需要高速查找的位置

• python3.0之后取消了字典大小比较
  • 可以根据键比较
  • sorted(d1.items()) < sorted(D2.items())

# 解压缩 list 和 tuples 都可以
conorinates = (1, 3, 5)
x, y, z = conorinates

# distionaries 字典 （ 键值对）:key值唯一
customer = {
    "name": "binge kong",
    "age": 30
}
# 以键访问字典中相对应的值，当不存在键时报错
print(customer["name"])
# get方式访问键值对,get（key) 或者get（key,默认value)
# 如果该键在字典中不存在，则以默认值作为value
print(customer.get("age","10"))
# 更新字典的键的对应值：直接对键值赋予新的value

# test
phone = str(input("Phone: "))
map = {
    "1": "one",
    "2": "two",
    "3": "three",
    "4": "four"
}
result = ""
for ch in phone:
    result += map.get(ch, "!") + " "
print(result)

dict 的排序

• 对于哈希表无法直接排序，但可以获取哈希表的键值集合，用list的sort方法对其进行排序，从而间接实现对字典的排序

D = {'a':1, 'b':2'}
L = list(D.keys())
L.sort()
for key in L:
    print D[key]

• 最新的sorted内置函数

for key in sorted(D):
    print D[key]

set 集合

• set是一组key的集合，但不存储value,没有重复元素
  • 无序且不重复的集合
• 将其他类型进行赋值，以达到去重的效果

1. 创建集合

• 创建空集合
  • s = set()
• s = set([1,2,3])

2. 添加/删除元素

添加 - add((key)

• s.add(4)

删除 - remove(key)

• s.remove(4)

3. 集合运算

• 集合差值

  • x - y

• 集合或

  • x | y

• 集合与

  • x & y

• 集合异或

  • x ^ y

• 集合元素个数比较 > < =

python的可变对象与不可变对象

1. list是可变对象，list中的元素是可变的

a = ['a','d','c']
a.sort()
print(a) -> ['a','c','d']

2. string是不可变对象

• 如果要修改string，其实就是修改副本

a = 'abc'
print(a.replace('a','A'))
print(a)

结果
  Abc
  abc

流程控制结构

• 三大流程控制结构
  • 顺序结构
  • 选择结构
  • 循环结构

1. 选择（条件控制结构）

• if
• if else
• if elif else

if 条件 :
	内容
	
# 嵌套
if 条件1：
	xx
elif 条件2：
	xxx
else:
	xxx

• 三元运算符
  • 适用于简单的条件运算

# 如 获取 a,b中的较大值
c = a if a >= b else b

• 判断条件的省略用法
  • string类型
    • 空字符串为 False，其余都是True
  • int
    • 0为False，其余都是True
  • 对象类型
    • None为False，其余都为True

2. 循环控制结构

while循环

while 条件:
	内容

for 循环

• 主要用于遍历有序的序列对象中的元素
• 遍历方式1
  • for ... in ...
    • 可以一次将list或者tuple中的每个元素迭代
  • range(start,stop[,step]) 函数
    • start
      • 起始边界，默认是0
    • stop
      • 结束边界（不包含）
    • step:
      • 间隔，步长

# 打印5以内的数字
for number in range(5):
    print("current number = ", number)

# 打印5以内的奇数
for number in range(1,5,2):
    print("current number = ", number)

• 迭代器
  • 大多数容器for遍历时采用迭代器
  • for在容器对象中调用iter(),它返回一个定了next()方法的迭代器对象，用于逐一访问元素，没有元素后抛出异常通知for语句停止循环

break

• 跳出当前循环

continue

• 跳过本次循环，不执行continue后面的循环体内容，进入下一次循环

对比

• for 适合 遍历已知的list等，直接调用的c源码，较快
• while 是通过解释器逐步运行，间接调用 c源码

三、函数

• 函数名可以看做是变量，可以把函数名赋值给一个变量（起别名）
• 函数定义
  • def 函数名（参数列表）：缩进后是函数代码
• 函数调用
  • 为函数局部变量生成一个新的符号表，用于存储函数的变量
  • 变量引用时
    • 首先在局部符号表查找
    • 然后是包含函数的局部符号表
    • 然后是全局符号表
    • 最后是内置名字表
• 没有返回值的函数会 自动返回一个none
• 多个返回值其实返回的是tuple，在语法上省略了括号，多个变量可以同时接受一个tuple,实际上 还是只有一个返回值tuple

# 函数定义，先定义后调用,定义方法后空两行
def greet_user():
    print('hi zhuzhu !')
    print('welcome to my home.')


print("start")
greet_user()
print('finish')


def greet_user(first_name,last_name):
    print(f'hi {first_name} {last_name}')
    print('welcome to my home.')


print("start")
greet_user('binge', 'kong')
print('finish')

函数参数

1. 默认参数

• 当没有传参时采用默认参数
• 注意：默认值只能被赋值一次，这使得默认值是可变对象时会有所不同

# 指点参数位置：关键字参数
greet_user(last_name='binge', first_name='kong')


# 带返回值的函数定义
def square(width, long):
    return width * long


print(square(8,10))

# 默认值只能赋值一次

def f(a,L = []):
    L.append(a)
    return L
print(f(1))
print(f(1) == f(2))
print f(3)
结果：
  [1]
  True
  [1, 1, 2, 3]

# 不共享操作

def f(a,L = None):
    if L is None:
        L = []
    L.append(a)
    return L
print(f(1))
print(f(1) == f(2))
print f(3)

结果
  [1]
  False
  [3]

• def f(a, b = "binge",c = "zhuzhu"):
  • 调用方式
    • 接受一个必选参数和可选参数
      • f(1000)
      • f（1000, b = "xxx")
      • f(1000, c = 'xxx')
    • 给出所有参数
  • 错误调用
    • 缺固定参数
  • 当默认参数同类型是，要给出关键字
    • f(10000, "xxx")
      • xxx不知道是b还是c
  • 关键字参数必须跟在位置参数后面

2. 可变参数

• 引入 两个* * 参数，它接收一个字典(包含所有未出现在形参列表的元素），一个*参数，它接收一个元组

def temp(*args,**kwargs):
    pass

# 调用

temp("binge",'xxx','xxx', name = xxx, number = xxx)

可变参数 *

• 收集所有未匹配的位置参数组成一个tuple对象，局部变量args指向此tuple对象
• 以tuple形式传递，这些可变参数被包装在一个元组，方便进行参数个数未知时调用，在这些可变个数的参数前，可以多个普通参数
• 还可用于解包tuple对象的每个元素，作为一个一个的位置参数传入函数
• 注意：
  • *在C语言中是取内容运算符，变量前加该符号意为指针变量，Python中只是一个标识符，表示将以tuple形式传递，星号本身有”全部的”意思, 两者无任何关系
  • 调用包含 * args参数的函数时，不要直接传入一个tuple对象，如果传入的是一个tuple对象，那么这个tuple对象只会成为未匹配的，函数内组装的tuple对象中一个元素而已。我们可以将tuple对象的元素使用元组解包语法传入，解包语法：*tuple

my_tuple = ("wang","yuan","wai")
 
temp(*my_tuple)
#---等同于---#
temp("wangyuan","yuan","wai")

可变参数 **

• 收集所有未匹配的关键字参数组成一个dict对象，局部变量kwargs指向此dict对象
• 关键字参数传递的是参数名:参数值 的 键值对
• 还可用于解包dict对象的每个元素，作为一个一个的关键字参数传入到函数中
• 注意
  • 调用包含 * * kwargs参数的函数时，不要直接传入一个字典对象，一个字典对象只算一个参数，此时会报错，因为一个dict对象不符合关键字参数的语法规范，字典对象可以使用字典解包语法，解包语法：* * dict

my_dict = {"name":"wangyuanwai","age":32}
 
temp(**my_dict)
#----等同于----#
temp(name="wangyuanwai",age=32)

3. 应用场景

当函数可以接受一个参数，也可以接受数量不定的参数

def print_str(first, *second):
    print(first)
    print(second)
    
# 调用
print_str("hello","美女","小猫","青蛙")
# 结果  
hello
('美女', '小猫', '青蛙')

• 解析
  • 函数调用时传入的参数，会按照从左到右的顺序依次在函数中使用，最左侧的参数先由位置参数first使用（匹配），剩下的所有未匹配的参数会被自动收集到1个新的tuple对象中，而局部变量second会指向这个新的tuple对象

参数场景2

def printStr(first, **dict):
    print(str(first) + "\n")
    print(dict)
 
 
printDic = {"name": "tyson", "age":"99"}
 
# 调用（解包）
printStr(100, **printDic)
 
#等同于
 
printStr(100, name = "tyson", age = "99") 

• 函数调用时，传入的关键字参数有匹配的位置参数时，则位置参数优先使用（匹配）这些关键字参数，剩余所有未使用（未匹配）的关键字参数会在函数内组装进一个dict对象中，组装后dict对象会赋值给变量名anything，此时局部变量anything指向一个dict对象

匿名函数 lambda表达式

• 参考文章
  • 细说Python的lambda函数用法，建议收藏 - 知乎 (zhihu.com)

• lambda形式

  • 优点
    • 可以创建短小的匿名函数，减少了代码的冗余
    • 代码的可读性更强，程序看起来更加简洁
  • 可以用于任何需要的函数对象，只能单独一个表达式
  • 可以用于从外部作用域引用变量

• 语法格式

  • lambda argument_list:expersion
    

  • argument_list是参数列表

  • expression是一个关于参数的表达式，表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的

map函数

• map() 会根据提供的函数对指定序列做映射

• map(function, iterable, ...)
  

• 参数

  • 第一个参数 function 以参数序列中的每一个元素调用 function 函数

• 返回值

  • Python 2 返回包含每次 function 函数返回值的新列表
  • Python 3 返回迭代器

# 普通方式定义函数：
def sq(x):
    return x*x

# python2中返回list, python3中返回map对象
L = list(map(sq,[y for y in range(10)]))

# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# lambda表达式
list(map(lambda x: x*x,[y for y in range(10)]))

# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

1. 调用方式

• 像普通函数 传参调用

  • c=lambda x,y,z:x*y*z
    c(2,3,4)
    

• 函数后面直接传参

  • (lambda x:x**2)(3)
    

2. 作为函数参数

• 将lambda函数作为参数传递给其他函数比如说结合map、filter、sorted、reduce等一些Python内置函数使用

• 普通函数参数

  • fliter(lambda x:x%3==0,[1,2,3,4,5,6])
    

• sorted函数结合使用

  • a=[('b',3),('a',2),('d',4),('c',1)]
    
    #按照第一个元素排序
    sorted(a,key=lambda x:x[0])
    # 结果
    [('a',2),('b',3),('c',1),('d',4)]
    
    # 按照第二个元素排序
    sorted(a,key=lambda x:x[1])
    # 结果
    [('c',1),('a',2),('b',3),('d',4)]
    

• 与map结合

  • squares = map(lambda x:x**2,range(5)
    print(list(squares))
    [0,1,4,9,16]
    

• reduce函数

  • reduce() 函数会对参数序列中元素进行累积

  • def add(x, y) :            # 两数相加
        return x + y
    sum1 = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
    
    from functools import reduce
    sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 计算列表和：1+2+3+4+5
    
    
    

• 判断字符串是否以某个字母开头有

  • Names = ['Anne', 'Amy', 'Bob', 'David', 'Carrie', 'Barbara', 'Zach']
    B_Name= filter(lambda x: x.startswith('B'),Names)
    print(B_Name)
    
    # 结果
    ['Bob', 'Barbara']
    

• 求两个列表元素的和

  • a = [1,2,3,4]
    b = [5,6,7,8]
    print(list(map(lambda x,y:x+y, a,b)))
    # 结果
    [6,8,10,12]
    

• 求字符串每个单词的长度

  • sentence = "Welcome To Beijing!"
    words = sentence.split()
    lengths  = map(lambda x:len(x),words)
    print(list(lengths))
    # 结果
    [7,2,8]