python中变量名命名规则

  • 普通变量：max_value
  • 全局变量：MAX_VALUE
  • 内部变量：_local_var
  • 和关键字重名：class_
  • 函数名：bar_function
  • 类名：FooClass
  • 布尔类型的变量名用 is,has 这类词语前缀
    is_superuser
    has_errors
    allow_empty
  • 释义为数字的单词
    port
    age
    radius
  • 以_id 为结尾的单词
    user_id
    port_id
  • 以 length/count 开头或结尾的词
    length_of_username
    max_length
    users_count
    注：不要用名词的复数形式来作为 int 类型的变量名，因为名词的负数形式更像是一个容器。建议使用 number_of_apples 或 trips_count；
  • 超短命名
    数组索引三剑客 i、j、k
    某个整数 n
    某个字符串 s
    某个异常 e
    文件对象 fp

变量注解

在Python3.5之后，可以使用类型注解功能来注明变量类型，在变量后添加类型，并用冒号隔开。

def repeat_message(message: str, count: int) -> str:
    return message * count

算术运算符

  • // 取整除
  • % 取余
  • ** 幂

不同类型变量之间的计算

  • 数字型变量之间可以直接计算；
  • 如果变量是 bool 型，在计算时，true 对应的是1，false 对应的是0；
  • 字符串变量之间使用 + 拼接字符串。

获取输入的信息-input

  • 字符串变量 = input("提示信息")

input 输入的数据类型都是字符串类型

格式化输出

  • %s --字符串
  • %d --有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
  • %f --浮点数，%.2f 表示小数点后只显示两位，会四舍五入
  • %% --输出%
vb1 ='Tom'print("hello %s"% vb1)
vb2 =5
print('有符号十进制整数：%d'% vb2)
print('输出显示位数的整数：%06d'% vb2)
vb3 =3.1415926
print('保留两位小数：%.2f'% vb3)
print('保留三位小数：%.3f'% vb3)
vb4 =80
print('正确率为：%d%%'% vb4)

hello Tom
有符号十进制整数：5
输出显示位数的整数：000005
保留两位小数：3.14
保留三位小数：3.142
正确率为：80%

逻辑运算

  • and：
    条件1 and 条件2
  • or：
    条件1 or 条件2
  • not：（取反）
    not 条件
a =10
b =20
c =10
if c == a and c == b:
    print('right')
else:
    print('error')

error
a =10
b =20
c =10
if c == a or c == b:
    print('right')
else:
    print('error')

right

循环-while

初始条件设置 -- 通常是重复执行的 计数器

while 条件 1:

条件满足时，做的事情 1

条件满足时，做的事情 2

条件满足时，做的事情 3

……

while 条件 2:

条件满足时，做的事情 1

条件满足时，做的事情 2

条件满足时，做的事情 3

……

处理条件 2

处理条件 1

print 函数增强

在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行；

如果不希望末尾增加换行，可以在 peint 函数输出内容的后面增加,end=""

其中""中间可以指定 print 函数输出内容之后，继续希望现实的内容；

语法格式如下：

print("*",end="")

转义字符

  • \t--在控制台输出一个制表符，协助在输出文本时，垂直方向，保持对齐
  • \n--在控制台输出一个换行符
  • \r--回车
  • \--反斜杠符号
  • \'--单引号
  • \"--双引号

列表

  • 列表通过索引取值，列表索引从0开始，且不能超过范围；
  • len(列表)--获取列表的长度
  • 列表.count(数据)--数据在列表中出现的次数
  • 列表.index(数据)--获取数据第一次出现的索引
  • del 列表 [索引]--删除指定索引的数据
  • 列表.remove[数据]--删除第一个出现的指定数据
  • 列表.pop--删除末尾数据
  • 列表.pop(索引)--删除指定索引的数据
  • 列表.insert(索引,数据)--在指定位置插入数据
  • 列表.append(数据)--在末尾追加数据
  • 列表.extend(列表 2)--将列表2的数据追加到列表1
  • 列表.sort()--升序排序
  • 列表.sort(reverse=True)--降序排序
  • 列表.reverse() 反转/逆序

元祖

  • Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改；
  • 创建空元组：info_tuple = ()
  • 元组中只包含一个元素时，需要在元素后面添加逗号：info_tuple = (50, )
  • len(元组)--获取元组的长度 n+1；
  • 元组.count(数据)--数据在元组中出现的次数；
  • 元组 [索引]--从元祖中取值；
  • 元组.index(数据)--获取数据第一次出现的索引。

元组和列表之间的转换

  • 使用 list 函数可以把元组转换成列表
    list(元组)
  • 使用 tuple 函数可以把列表转换成元组
    tuple(列表)

字典

  • Python 里的字典在底层使用了哈希表 (hash table) 数据结构
  • 和列表的区别：列表 是 有序 的对象集合 字典 是 无序 的对象集合

Python3.6 之后的字典是有序的，如果解释器版本没有那么新，也可以使用 collections 模块里的 OrderedDict 方法保证字典的有序性。
OrderedDict 与新版字典在比较上面的区别：在对比两个内容相同但顺序不同的字典时，新版字典会返回 True，OrderedDict 则会返回 False。 

from collections import OrderedDict
    d = OrderedDict()
    d['one'] = 1
    d['two'] = 2
    print(d)

    OrderedDict([('one', 1), ('two', 2)])
  • 键必须是唯一的；
  • 值可以取任何数据类型，但键只能使用字符串、数字或元组；
  • 字典.keys()--所有 key 列表；
  • 字典.values()--所有 value 列表；
  • 字典.items()--所有（key，value）元组列表；
  • 字典 [key]--可以从字典中取值，key 不存在会报错；
    1.返回的数据类型类似列表，但不是真正意义的列表，没有 append() 方法;
    2.但是可以用于 for 循环;
    3.可以用 list() 方转换成真正的列表;
  • 字典.get(key)--可以从字典中取值，key 不存在不会报错；
  • del 字典 [key]--删除指定键值对，key 不存在会报错；
  • 字典.pop(key)--删除指定键值对，并且返回删除键对应的值，key 不存在会报错；
  • 字典.pop(key, default=msg)--删除指定键值对，并且返回删除键对应的值，key 不存在不会报错，会返回 msg；
  • 字典 popitem() 方法返回并删除字典中的最后一对键和值。
  • 字典.clear()--清空字典；
  • 字典 [key] = value
    如果 key 存在，修改数据
    如果 key 不存在，新建键值对
  • 字典.setdefault(key,value)
    如果 key 存在，不会修改数据
    如果 key 不存在，新建键值对
  • 字典.update(字典2)--将字典2的数据合并到字典1，如果字典2中有和字典 1 重复的键值对，则替换字典 1 中的键值对；
  • 生成字典的方法：d = dict.fromkeys(["name","age","code"],0) #0 为默认值

字符串

  • 拼接多个字符串，使用 str.join 和 +=同样好用；
  • len(字符串)--获取字符串的长度；
  • 字符串.count(字符串)--小字符串在大字符串中出现的次数；
  • 字符串 [索引]--从字符串中取出单个字符；
  • 字符串.index(字符串)--获得小字符串第一次出现的索引；
  • string.istitle() | 如果 string 是标题化的 (每个单词的首字母大写) 则返回 True；
  • string.startswith(str) | 检查字符串是否是以 str 开头，是则返回 True；
  • string.endswith(str) | 检查字符串是否是以 str 结束，是则返回 True；
  • string.find(str, start=0, end=len(string)) | 检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1 ；
  • string.index(str, start=0, end=len(string)) | 跟 find() 方法类似，不过如果 str 不在 string 会报错；
  • string.replace(old_str, new_str, num=string.count(old)) | 把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次；
  • string.capitalize() | 把字符串的第一个字符大写；
  • string.title() | 把字符串的每个单词首字母大写；
  • string.lower() | 转换 string 中所有大写字符为小写；
  • string.upper() | 转换 string 中的小写字母为大写；
  • string.swapcase() | 翻转 string 中的大小写；

字符串 - 切片

  • 切片方法适用于字符串、列表、元组；
  • 字符串 [开始索引:结束索引:步长]；
  • 切片：正反向索引（正:从 0 开始，反:从-1 开始）

切片索引：[start <-step]

  • start:开始截取的位置，包含在截取内容内
  • end:结束截取的位置，结束截取的位置并不包含
  • step:截取的步长，默认值为 1
  • step:为正，表示从左到右进行截取，start 必须在 end 之前（从左开始算前，下标必须从左到右）
  • step:为负，表示从右到左进行截取，start 必须在 end 之前（从右开始算前，下标必须从右到左）
  • s = "hello,world"
    print(s[:]) # 取全部
    print(s[1:]) # 从第 2 位取到最后
    print(s[:-1]) # 从开始取到倒数第二位
    print(s[::2]) # 步长为 2
    print(s[::-1]) # 反序

指定的区间属于左闭右开型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引
从 起始位开始，到 结束位的前一位 结束（不包含结束位本身)
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字可以省略，冒号不能省略
步长默认为 1，如果连续切片，数字和冒号都可以省略
索引的顺序和倒序：
在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
所谓倒序索引就是 从右向左 计算索引
最右边的索引值是 -1，依次递减

字符串格式化

  • 优先使用 f-string 方式
将username靠右对齐，左侧补空格一共到20位username = 'Lili'
print(f'{username:>20}')
               Lili
  • 对参数复用时可以使用 str.format 方式
username = 'Lily'
sore = 10
print('{0}:{0}的成绩是{1}'.format(username, sore))

集合

  • 集合是一个无序的可变容器类型，他最大的特点就是成员不能重复
  • 要初始化一个空集合只能调用 set() 方法，因为{}表示的是一个空字典，而不是一个空集合
  • 集合也有自己的推导式-nums = {n for n in range(10) if n % 2 == 0}
  • 集合是可变类型，可以通过.add() 追加元素
  • 可以使用 update 方法可以将一个可迭代元素更新到集合中
s1 = set([1,2,3])
s2 = set([2,3,4])
s1.update(s2)
s1.update('hello')
print(s1)
{1, 2, 3, 4, 'o', 'h', 'e', 'l'}
  • 使用.remove() 可以删除集合中的元素，但元素不存在会报错-KeyError:
  • 使用.discard() 可以删除集合中的元素，元素不存在也不会报错
  • 集合的元素不可以修改，只能先删再加
  • 我们可以使用 in 判断某个元素是否在某个集合中，不能在集合中取值，只能使用 for 循环遍历集合中的元素
  • 集合只能存放可哈希对象
s1 = set([1,2,3])
s1.add([1])
TypeError: unhashable type: 'list'

集合的运算

集合支持集合运算，比如交集、并集、差集。所有的操作都可以用两种方式：方法和运算符；

  • 交集
fruits_1 = {'apple','orange','pineapple'}
fruits_2 = {'tomato','orange','grapes','mango'}
print(fruits_1 & fruits_2)
{'orange'}
  • 并集
fruits_1 = {'apple','orange','pineapple'}
fruits_2 = {'tomato','orange','grapes','mango'}
print(fruits_1 | fruits_2)
{'tomato', 'pineapple', 'orange', 'apple', 'grapes', 'mango'}
  • 差集（前有后没有）
fruits_1 = {'apple','orange','pineapple'}
fruits_2 = {'tomato','orange','grapes','mango'}
print(fruits_1 - fruits_2)
{'apple', 'pineapple'}
  • symmetric_difference：返回两个集合中不重复的元素
fruits_1 = {'apple','orange','pineapple'}
fruits_2 = {'tomato','orange','grapes','mango'}
print(fruits_1.symmetric_difference(fruits_2))
{'apple', 'mango', 'tomato', 'pineapple', 'grapes'}
  • issubset：用于判断集合的所有元素是否都包含在指定集合中
fruits_1 = {'apple','orange','pineapple'}
fruits_2 = {'apple','orange','pineapple','water'}
print(fruits_1.issubset(fruits_2))
print(fruits_2.issubset(fruits_1))
True
False

Python 循环结构

  • 什么时候用 for：当循环次数是一定的，或者是循环对象是一定的，比如说在一个固定的字符串或列表中进行循环，那么最好使用 for
  • 什么时候用 while：当循环次数不是一定的，只是满足某个条件时才进行循环，那么最好使用 while
  • 没有 do…while…循环
  • 循环里面加 else：当循环执行完毕时，else 才会执行；如果循环在中间退出，则 else 不会运行
  • break&continue：不管是 break 还是 continue 都只作用于当前循环

匿名函数-lambda

  • lambda 关键字能够帮我们创建小型的匿名函数：
  • lambda x:express
  • lambda 返回的是该匿名函数的指针
  • func = lambda x,y:x*y
    print(func(2,3))