pycharm professional 2018.1 激活
https://blog.csdn.net/sunqiande88/article/details/80137151
print(r'test ') # 所有内容当做普通字符打印
'''
三个单引号内可以随意使用单引号和双引号
'''
print('test
more line') # 测试换行
# Python是动态强类型语言
# 静态语言：可以在编译时进行检查，动态语言只能在运行时发现错误
# 强类型语言：需要自己强制转换变量类型
# 常量：没有所谓的常量。放在内存中固定的位置，叫字面常量
# Python3除法：1/5=0.2(自然除) 1//5=0(整除)
# Python2除法：1/5=0(整除)
# Python3：2的3次方：2**3
# 成员运算符：in、not in
# 身份运算符：is、is not
# 运算符优先级：算数运算符 > 位运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
# 内存管理
# 引用计数：一个对象被多少个变量引用
# b = 6 表示6被b对象引用了一次
# 当变量引用数=0时，会被垃圾回收机制GC，包括内存整理。同Java
# 程序控制：顺序、分支、循环
# 分支
if 2>1:
print('1 less than 2')
# 多分支
if condition1:
block1
elif condition2:
block2
elif condition3:
block3
...
else:
block
# block: 1 表示代码块； 2 表示阻塞
# 真值表
# 1 "" 假
# 2 "str" 真
# 3 0 假
# 4 非0 真
# 5 () 假
# 6 [] 假
# 7 {} 假
# 8 None 假
# while循环
while condition：
block
# for循环(操作集合)
for element in iteratable:
block
# 举例
for i in range(10):
print(i+1)
# range
# 1 可以使用ipython进行帮助查看 help(range)
# 2 语法：range(stop) 仅指定结束。举例：range(10)是0-9
# 3 语法：range(start,stop[, step]) 指定开始和结束，并指定步长step
# continue 结束本次循环，进入下次循环
# break 退出循环
# 数据类型
# 数值型：int、float、complex、bool
# int:python3都是长整形
# complex：用于科学计算，由实数和虚数部分组成
# 序列对象：str、list、typle
# 键值对：set、dict
# 数据类型转换
# int(x) 返回一个整数
# float(x)
# complex(x)
# bool(x)
# math
# 向下取整：math.floor(1.8) 结果1
# 向上取整：math.ceil(1.8) 结果2
#round
# 四舍六入五取偶：round()
# 数字处理函数
# min()
# max()
# pow(x,y)x的平方=x**y
# math.sqrt() 开平方
# 进制
# bin() 十进制转二进制
# oct() 十进制转八进制
# hen() 十进制转十六进制
# int(其他进制,要转换的进制)
# int('1010', 2) '1010'转换为二进制，结果10
# 类型判断
# type() 查看类型
# isinstance(6, int) 判断类型
# isinstance(6, (int, str)) 是否属于多种类型的一种
# 列表list：[]
# 可以放任意类型的元素、有序、元素可重复
# 有序：可以使用索引
# list长度是可变的
# list = list() 空
# list = [] 空
# list = [2, 'xiao', 10]
# list = list(range(5))
# Python不能初始定义大小
# 正索引：从0开始
# 负索引：从-1开始
# 列表查询
# 定义：lst = [1, 2, 3, 4, 2, 5, 2]
# 查看list中元素的索引：lst.index(2)，返回1
# lst.index(value, [start, [stop]]) start表示索引开始，stop表示索引结束
# lst.count(2)，返回3
# 时间复杂度：表示算法的效率
# O(1) ：表示一次就能算出结果。执行有限次数
# O(n) ：表示n次就能算出结果。执行跟元素相同的次数
# 随着数据规模的增加，效率会下降
# 列表长度：有一个地方记录此值
# len(lst) len()是内置函数，公用
# 列表元素修改：
# lst[5] = 100
# 列表追加、插入
# lst.append(object)
# lst.append(99) 返回值是None - Python3.5
# 时间复杂度是O(1)
# lst.insert(index, object) - list中少使用，链表比较适合insert
# lst.insert(index, object) 返回值是None
# 时间复杂度：大数据量时，只要不是尾部，需要挪动大量元素，效率极低
# 再次定义列表
# lst1 = [1, 2, 3]
# lst2 = [4, 5, 6]
# lst3 = lst1 + lst2 连接lst1和lst2，定义lst3
# lst4 = lst1*2 重复lst1，定义lst4
# extend(iteratable) 返回None
# lst1.extend(lst2) 重新定义lst1，追加lst2
# 列表删除
# lst.clear() 清空列表，大规模 会引起垃圾回收问题
# lst.remove(value)
# lst.remove(2) 从左到右移除一个值，少用
# lst.pop([index])
# lst.pop() 弹出最后的元素，效率高
# lst.pop(0) 弹出第0个元素，少用
# 列表翻转
# reversed()
# 列表排序
# sort(key=None, reverse=False)
# lst.sort() 默认升序
# lst.sort(reverse=True) 降序
# lst.sort(key=str, reverse=True) 按str排序
# 20 in lst 20是否在集合内
# 30 not in lst
# [3, 4] in lst
# for x in lst:
# 列表复制
# lst0 = list(range(4))
# lst2 = list(range(4))
# id(lst0) 返回78677128
# id(lst2) 返回72007368 表明内存id不一样
# lst0 == lst2 比较值，返回True
# lst0 is lst2 比较内存地址，返回False
# lst0 = lst1 同时指向同一个内存地址
# lst5 = lst0.copy()
# lst5 == lst0 True
# lst5 is lst0 False，内存地址不同
# 拷贝：浅拷贝、深拷贝
# 浅拷贝：只对第一层负责，嵌套内容不管
# 深拷贝：对嵌套内容也进行拷贝
# import copy
# lst5 = copy.deepcopy(lst0)
# 随机数
# import random
# random.randint(a, b) 随机整数，返回[a,b]
# random.choice([1, 2, 3, 4, 5]) 给定序列选择
# random.randrange([start,]stop[,step])
# random.randrange(1, 10, 2) 返回奇数
# random.shuffle(list) 打乱列表
# 元组tuple：()
# 不可变集合，有序可重复。
# 不可变，节省内存
# tuple() 空元组基本没有
# tuple(iterable)
# tuple(range(1, 7, 2))
# tuple(1, 2, 3, 4, 9)
# tuple(1,) 一个元素的元组
# tuple(1,)*5
# 元组元素的访问
# 正索引：从0开始，从左到右
# 负索引：从-1开始，从右到左
# tuple[index]
# 元组查询
# index(value,[start,[stop]]) 返回第一个匹配的值
# count(value) 返回匹配的次数
# index和count时间复杂度O(n)，随着规模增加，效率下降
# len(tuple) 长度
# 命名元组 namedtuple
# namedtuple(typename, field_names, verbose=False, rename=False)
# field_names可以用空格分割，verbose/rename不用理会
from collections import namedtuple
Student = namedtuple('Student', 'name age') 比类占用内存小
tom = Student('tom', 20)
jerry = Student('jerry', 18)
tom.name
jerry.name
# 冒泡排序：基础冒泡排序，每趟比较次数减1次
lst = [1, 9, 8, 5, 6, 7, 4, 3, 2]
length = len(lst)
for i in range(length):
for j in range(length-i-1):
if lst[j] > lst[i]:
tmp = lst[j]
lst[j] = lst[j+1]
lst[j+1] = tmp
print(lst)
# 冒泡排序：某一趟扫描，如果发现没有可交换的，可以退出
lst = [1, 2, 3, 4, 5, 6, 7, 9, 8]
length = len(lst)
for i in range(length):
flag = False
for j in range(length-i-1):
if lst[j] > lst[i]:
tmp = lst[j]
lst[j] = lst[j+1]
lst[j+1] = tmp
flag = True
if not flag: # 内部循环一趟后，发现flag不是True，表示没有交换
break # 没有交换退出外层循环，冒泡排序结束
print(lst)
# 冒泡排序：时间复杂度O(n平方)
# 字符串：有序的字符集合
# 可以使用单引号、双引号、三引号引住
# 不可变
# Python3中默认是utf8
# slq = """select * from user where name='tom';"""
# for i in sql: 有序，可迭代
# print(i)
# 字符串列表：lst = list(sql)
# 字符串连接
# 加号：+
# str.join(iterable) 返回字符串
# str = 'abc'
# ' '.join(str) 输出'a b c d'，用空格隔开str中的每个字符
# lst = ['1', ['a','b'], '2'] 不能join(lst)，引用类型不能被join
# 字符串分割*
# split：返回列表
# split(sep=None, maxsplit=-1) 从左边开始切
s1 = "I'm a super student."
s1.split() 按空格切割，返回["I'm", "a", "super", "student"]
# rsplit(sep=None, maxsplit=-1) 从右边开始切
# splitlines([keepends]) 按照行分割字符串
# 行分隔符包括：
、
、
等
'ab c
de fg
kl
'.splitlines() 不保留最后的
'ab c
de fg
kl
'.splitlines(True) 保留最后的
# partition：返回元组
# partition(sep)从左到右，遇到分隔符就切一刀，返回(head, sep, tail)
# rpartition(sep) 从右到左
# 字符串大小写
upper() - str.upper()
lower() - str.lower()
swapcase() - str.swapcase() 交互大小写
# 字符串排版
str.titile() 标题每个单词都大写
str.capitalize() 首个单词大写
str.center(width[, fillchar]) width：打印宽度；fillchar：填充字符
str.zfill(width) width：打印宽度
str.ljust(width[, fillchar]) str左对齐
str.rjust(width[, fillchar]) str右对齐
# 字符串修改*
str.replace(old, new[,count])
'www.magedu.com'.replace('w', 'p') w全部替换成p
'www.magedu.com'.replace('w', 'p'， 2) w替换成p，仅替换两次
strip([chars])
str = ' You are so nice '
# 去除两端空格：str.strip()
# 去除两端的e: str.strip('e')
# 去除左边空格：str.lstrip()
# 去除右边空格：str.rstrip()
# 字符串查找
# find(sub[, start[, end]]) 返回int，没有返回-1
# [start, end)找到就立即返回
# rfind(sub[, start[, end]]) 从右向左
# index(sub[, start[, end]]) 没找到抛异常ValueError
# rindex(sub[, start[, end]]) 从右向左
# count(sub[, start[, end]]) 统计子串出现的次数 *
# 时间复杂度O(n)
# len(string) 时间复杂度O(1)
# 字符串判断*
# endswith(suffix[, start[, end]]) 返回布尔值
# 在指定区间[start, end)，字符串是否以suffix结尾
# startswith(perfix[, start[, end]]) 返回布尔值
# 在指定区间[start, end)，字符串是否以perfix开头
# 字符串判断is系列
# isalnum() 是否字母数字组成
# isalpha() 是否是字母
# isdecimal() 是否包含十进制数字
# isdigit() 是否全部数字(0~9)
# isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
# islower() 是否小写
# isupper() 是否大写
# isspace() 是否只包含空白符
# 字符串格式
"I am %03d" % (20,) %03d表示3位数字，0是占位使用
"I am %s" % 'python'
"I am %-5d" % (20,) 负号表示左对齐
# 字符串格式化* （代替字符串拼接）
# "{}{xxx}".format(*args, **kwargs) 返回str
# args位置参数，是一个元组
# kwargs关键字参数吗，是一个字典
# {}表示占位符
# {n}索引匹配
# {xxx}表示关键字参数中名称一致
# {{}}表示打印花括号
# 位置参数："{}:{}".format('192.168.1.100', '8888')
# 关键字参数："{server}{1}:{0}".format(8888, '192.168.1.100', server='Ip info: ')
# 访问元素："{0[0]}.{0[1]}".format(('mama', 'com'))
# t = ('mama', 'com')
# "{}.{}".format(t[0].t[1]) 打印出mama.com
# 对齐
# "{0}*{1}={2:>02}".format(3, 2, 2*3) 打印3*2=06
# "{:^30}".format('centered') 打印 centered
# "{:*^30}".format('centered') 打印***********centered***********
# 进制
# bytes字节、bytearray字节数组（主要解决字符串问题）
# Python3引入两个新的类型
# bytes：不可变字节序列
# bytearray：字节数组，可变
# 编码与解码
# 编码：str.encode(encoding='utf-8', errors='strict') 返回bytes
# 解码：bytes.decode(encoding='utf-8', errors='strict') 返回str
# bytearray.decode(encoding='utf-8', errors='strict') 返回str
# bytes定义
# bytes() 空
# bytes(int)
# bytes(iterable_of_ints) bytes[0, 255]的放int的可迭代对象
# bytes([1, 3, 5]) 返回b开头的内容，表示不是字符串
# bytes(string, encoding[, errors]) bytes等价于string.encode()
# bytes(bytes_or_buffer) 从一个字节序列或buffer拷贝出一个新的不可变的bytes对象
# b前缀
# 基本ASCII：b'abc9'
# 使用16进制表示：b'x41x61'
# bytes操作
# tmp = b'abcdef'
# tmp.split(b'') 方法中参数也要加b前缀
# tmp.replace(b'f', b'k')
# tmp.find(b'b')
# bytes.fromhex(string) string必须是2个字符的16进制形式
# hex()返回16进制表示的字符串
# 'abc'.encode().hex()
# 索引：b'abcdef'[2] 返回该字节对应的数，int类型
# bytearray定义
# bytearray()
# bytearray(int)
# bytearray(iterable_of_ints)
# bytearray(string, encoding[, errors])
# bytearray(bytes_or_buffer)
# bytearray(b'abc'.encode())
# bytearray操作
# tmp = b'abcdef'
# bytearray(tmp).split(b'') 方法中参数也要加b前缀
# bytearray(tmp).replace(b'f', b'k')
# bytearray(tmp).find(b'b')
# bytearray(tmp).fromhex(string) string必须是2个字符的16进制形式
# hex()返回16进制表示的字符串
# bytearray(tmp).hex()
# 索引：bytearray(tmp)[2] 返回该字节对应的数，int类型
# bytearray操作
# append(int)
# insert(index, int)
# extend(iterable_of_ints)
# pop(index=-1)
# remove(value) 找不到抛异常
# 上述int类型值在[0, 255]
# clear()
# reverse()
# 切片：通过索引区间取出一段数据
# 线性结构：列表、元组、字符串、bytes、bytearray
# 可迭代：for ... in
# len() 可以获取长度
# 通过下标访问
# 可以切片
# sequence[start:stop] 表示返回[start,stop]区间的子序列
# 支持负索引
# start为0，可以省略
# stop为末尾，可以省略
# 超过右边界，取到末尾；超过左边界，取到开头
# start一定要在stop左边
# [:]取出全部元素，等效于copy()
# tmp = 'www.baidu.com'
# tmp = [4:10]
# tmp = [:10]
# tmp = [4:]
# tmp = [:]
# tmp = [:-1] 返回 'www.baidu.co'
# 步长：[start:stop:step] step可以正可以负
# step要和start:stop同向，否则返回空序列
# list('www.baidu.com')[4:10:2]
# tuple('www.baidu.com')[4:10:2]
# b'www.baidu.com'[4:10:2]
# bytearray(b'www.baidu.com')[4:10:2])
# IPython技巧（用于测试使用）
# help(name)查看指定名字的帮助，python的帮助
# obj? 列出obj对象的详细信息
# obj?? 列出更加详细信息
# Ipython特殊变量
# _ 表示前一次输出
# __表示倒数第二次输出
# ___表示倒数第三次输出
# _dh 目录历史
# _oh 输出历史
# Ipython的shell命令
# !command执行
# !ls -l
# files=!ls -l ls结果保存到列表中
# Ipython魔术方法
# %开头的方法
# % 行magic
# %% 多行magic
# %alias 定义一个系统命令的别名
# alias ll ls -l
# %timeit statement
# -n 一个循环loop执行语句多少次
# -r 循环执行多少次loop，取最好的结果
# %%timeit setup_code
# %cd
# %pwd
# %ls
# 注：%为Ipython内部实现；!依赖当前操作系统
# %%js、%%javascript 在cell中运行js脚本
# 集合 Set
# set翻译为集合
# collection翻译为集合类型，是一个大的概念
# set：无序、可变、不重复
# set定义
# set()
# set(iterable)
s1 = set()
s2 = set(range(5))
s3 = set(list(range(10)))
s4 = {} # dict
s5 = {9, 10, 11} # set
s6 = {(1, 2), 3, 'a'}
a7 = {[1], (1,), 1} # ?
# set元素
# set元素要求必须可以hash
# 目前絮聒不可hash的类型有list、set
# 元素不可以索引
# set可以迭代
# set增加
# add(elem) 增加，如果元素已经存在，什么都不做
# update(*others)
# 合并其他元素到set中
# 参考others必须是可迭代对象
# 就地修改
# set删除
# remove(elem) 移除，元素不存在则抛出KeyError异常
# discard(elem) 移除，元素不存在则什么都不做
# pop() -> item 移除并返回任意元素，空集合返回KeyError异常
# clear() 移除所有元素
# set修改
# 要么删除、要么增加新元素
# set查询
# 非线性结构，无法索引
# 根据key的hash值来查找，效率极高
# set遍历
# 可以遍历所有元素
# 成员运算符
# in、not in 判断元素是否在set中 （效率很高）
# set成员运算符的比较
# list和set的比较
# lst1 = list(range(100))
# lst2 = list(range(1000000))
# -1 in lst1 看耗时 1.22微秒
# -1 in lst2 看耗时 32ms 随着规模的增大，耗时增加
# set1 = set(range(100))
# set2 = set(range(1000000))
# -1 in set1 看耗时 32ns
# -1 in set2 看耗时 32.3ns 随着规模的增大，耗时不会受到太大影响
# set和线性结构
# 线性结构查询的时间复杂度O(n)，随着规模增大和增大
# 所以，线性结构查询时，尽量用索引
# set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)，查询时间跟规模无关
# 可hash类型
# 数值型：int float complex
# 布尔型：True、False
# 字符串：string、bytes
# tuple
# None
# 以上都是不可变类型，称为可哈希类型 - hashable
# 重点*
# set中的元素必须是hashable的
# set构造函数的元素是可迭代的，可迭代里面的元素必须是可hash
# set集合概念
# 全集：所有有元素的集合。如：实数集合
# 子集：A集合所有元素都在集合B中，A是B的子集，B是A的超集
# 真子集：A是B的子集，且A不等于B，A是B的真子集
# 真超集：A是B的子集，且A不等于B，B是A的真超集
# 并集：多个集合合并
# 交集：多个集合的公共部分
# 差集：集合中去除和其他集合的公共部分
# 集合运算 - 并集
# union(*others)返回多个集合合并后的新的集合
# | 运算符等同union
# update(*others)：返回多个集合合并后的结果，就地修改
# |= 运算符等同update
# a = {1,2,3}
# b = {1,2,4}
# tmp = a.union(b) - 等同于 tmp = a | b > 结果a、b不变，生成新的集合tmp
# tmp = a.update(b) - 等同于 tmp = a |= b > 结果a改变、b不变、tmp没有值
# 集合运算 - 交集
# intersection(*others) 返回和多个集合的交集
# & 运算符等同intersecton
# intersection_update(*others) 返回和多个集合的交集，就地修改
# &= 运算符等同于intersection_update
# 集合运算 - 差集
# difference(*others) 返回和多个集合的差集
# - 运算符等同difference
# difference_update(*others) 返回和多个集合的交集，就地修改
# -= 运算符等同于difference_update
# 集合运算 - 对称差集
# symmetric_difference(other) 返回两个集合不同的部分的集合
# ^ 运算符等同symmetric_difference
# symmetric_difference_update(*others) 返回两个集合不同的部分的集合，就地修改
# ^= 运算符等同于symmetric_difference_update
# 集合运算
# issubset(other) <= 判断当前集合是否是另一个集合的子集
# set1 < set2 判断set1是否是set2的真子集
# issuperset(other) >= 判断当前集合是否是另一个集合的超集
# set1 > set2 判断set1是否是set2的真超集
# isdisjoint(other) 当前集合和另一个集合没有交集，返回True
# 选择排序：选择极大或极小值，跟第一个进行交换
lst = [1, 3, 9, 8, 5, 2, 7, 4, 6]
length = len(lst)
for i in range(length):
maxValueIndex = i # 先假定第一个为最大值
for j in range(i+1, length): # 从第二个开始跟第一个比较
if lst[j] > lst[maxValueIndex]:
maxValueIndex = j;
if i != maxValueIndex: # 找到最大值的index后，进行交换
tmp = lst[i]
lst[i] = lst[maxValueIndex]
lst[maxValueIndex] = tmp
print(lst)
print('-------------------------------------')
# 选择排序：优化 - 每趟分别找到最大值和最小值
lst = [1, 3, 9, 8, 5, 2, 7, 4, 6]
length = len(lst)
for i in range(length // 2): # 循环少一半
maxValueIndex = i # 先假定第一个为最大值
minValueIndex = -i-1 # 假定最后一个为最小值
minOrigin = minValueIndex # 记录最小值的原始index
for j in range(i+1, length-i): # 从第二个开始跟第一个比较
if lst[j] > lst[maxValueIndex]:
maxValueIndex = j
if lst[- j - 1] < lst[minValueIndex]:
minValueIndex = - j - 1
if i != maxValueIndex: # 找到最大值的index后，进行交换
tmp = lst[i]
lst[i] = lst[maxValueIndex]
lst[maxValueIndex] = tmp
# 如果最小值被交换过，更新索引
if i == minValueIndex or i == length + minValueIndex:
minValueIndex = maxValueIndex
# 最小值索引不同，但值相同，不用交换了
if minOrigin != minValueIndex and lst[minOrigin] != lst[minValueIndex]:
tmp = lst[minOrigin]
lst[minOrigin] = lst[minValueIndex]
lst[minValueIndex] = tmp
print(lst)
print('-------------------------------------')
# 选择排序：优化 - 最大值最小值相等，跳出循环
lst = [1, 3, 9, 1, 1, 1, 1, 1, 1]
length = len(lst)
for i in range(length // 2): # 循环少一半
maxValueIndex = i # 先假定第一个为最大值
minValueIndex = -i-1 # 假定最后一个为最小值
minOrigin = minValueIndex # 记录最小值的原始index
for j in range(i+1, length-i): # 从第二个开始跟第一个比较
if lst[j] > lst[maxValueIndex]:
maxValueIndex = j
if lst[- j - 1] < lst[minValueIndex]:
minValueIndex = - j - 1
# 如果元素相同，结束循环
if lst[maxValueIndex] == lst[minValueIndex]:
break
if i != maxValueIndex: # 找到最大值的index后，进行交换
tmp = lst[i]
lst[i] = lst[maxValueIndex]
lst[maxValueIndex] = tmp
# 如果最小值被交换过，更新索引
if i == minValueIndex or i == length + minValueIndex:
minValueIndex = maxValueIndex
# 最小值索引不同，但值相同，不用交换了
if minOrigin != minValueIndex and lst[minOrigin] != lst[minValueIndex]:
tmp = lst[minOrigin]
lst[minOrigin] = lst[minValueIndex]
lst[minValueIndex] = tmp
print(lst)