19 python 数据类型
type() #查看数据类型
python 3 里没有长整型(long) ，python 2 里依然有

20 bytes 类型
三元运算
a,b,c = 1,3,5
d = a if a<b else c
16进制与二进制转换

encode(encoding="utf-8")
decode()

21 数据运算
二进制
计算机中能表示/存储的最小单位，是一个二进制位(bit)

22 列表的使用
定义 names=["a","b","c","d"]
切片 names[1:3] name[3] name[-1] name[-3:-1] name[-3:] name[0:3] #顾首不顾尾
追加 names.append("e")
插入 names.insert(1,"e")
修改 names[1]="b"
删除 names.remove="c"
del names[2] # 等同于 names.pop(2)
names.pop() # 默认删除最后1个,并返回该元素的值
索引 names.index("b") #返回 "b" 的下标
统计 print(names.count("b")) #统计同名数量
清空 names.clear()
反转 names.reverse() #序列排序反转
排序 name.sort() #按 ascii 排序(执行后改变列表顺序)
扩展 name.extend(另外一个排列名) #并入另外一个列表
删除 del names
复制 names2 = names.copy() #把names 浅 copy 到 names2(只copy第一层列表)

22 列表的使用2
浅copy
person=["name",["saving",100]]
# 三种方式,效果相同
import copy
p1=copy.copy(person)
p2=person[:]
p3=list(person)

深copy
import copy
name2 = copy.deepcopy(names)

扩展阅读：https://www.cnblogs.com/whatisfantasy/p/5956807.html

列表循环：
for i in names[0:-1:步长]:
print(i)
for i in names[::步长]:
print(i)

23 元组与购物车练习
元组： names = ("alex","jack","mike") # 元祖数据不可更改
names.count
names.index

enumerate(names) #打印下标

26 字符串常用操作
name = "your \t{name} is alex"

print(name.capitalize()) # 首字母大写
print(name.count("a")) # 统计字符"a"的出现次数
print(name.center(50,"_")) # 效果：_______________your {name} is alex_______________
print(name.endswith("ex")) # 判断字符串是否以"ex"结尾，此例返回 True
print(name.expandtabs(tabsize=30)) # tab 变成 30 个字符位置
print(name.find("name")) # 查找name,找到返回其索引(name的起始位置)，找不到返回-1
print(name.format(name='alex',year=23)) # 效果： your alex is alex # format拓展阅读：https://www.cnblogs.com/whatisfantasy/p/5975582.html
name.format_map
'ab23'.isalnum() # 是否是英文字母+阿拉伯数字
'abA'.isalpha() # 是否是英文字母
'1A'.isdecimal() # 判断是否是10进制数
'a'.isidentifier() # 判断是否是合法变量名
'1A'.isdigit() # 判断是否是数字
‘33'.isnumeric() # 判断是否是合法的标示符
‘33'.isspace() # 判断是否是空格
‘My Name Is'.istitle() # 判断是否是首字母大写
‘My Name Is'.isprintable() # 判断是否可打印，[tty，drive]不可打印
‘My Name Is'.isupper() # 判断是否是大写
'+'.join(['1','2','3','4']) # 列表拼成字符串,例： ' '.join(“ab c”.split())，可以把字符串中相邻的多余空格去掉，只保留一个空格,变成“ab c”
name.ljust(50,'*') # 长度50，左边用*补足
name.rjust(50,'*') # 长度50，右边用*补足
‘Alex’.lower() # 变小写
‘Alex’.upper() # 变大写
‘\nAlex’.lstrip() # 去左边的空格和换行
‘Alex\n’.rstrip() # 去右边的空格和换行
‘ Alex\n’.strip() # 去除头尾的空格和换行
p = str.maketrans("abcdef",'123456')
print("alex li".translate(p)) # 把p传入“alex li”,将字母替换成p对应的字符
‘alex li’.replace('l','L',1) # 把后面的参数替换前面的(第三个参数代表替换的数量)
‘alex li’.rfind('l') # 找 l
‘1+2+3+4’.split('+') # 按“参数”把字符串分割成列表
‘1+2\n3+4’.splitlines() # 按“\n”把字符串分割成列表
‘Alex Li’.swapcase() # 转换大小写
‘my name is'.title() # 给单词的首字母大写

# 字符串的格式化_方式1：
"Hi%s, your score is %d."%("bart",59)
表示如下
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
%% %
# 其他方式：扩展阅读：https://docs.python.org/3/library/string.html

# 计算字符串长度
len()函数
计算str的字符数或 bytes的字节数

27 字典操作
字典无序(没有下标)
字典通过 key 取值
info = {
'stu1' :"jam",
'stu2' :"amy",
'stu3' :"lily",
}
# 删除
del info["stu1"]
info.pop("stu1")
info.popitem() # 随机删除
# 新增 & 修改
info["stu1"] = "mike"
# 查找
print(info.get('stu1'))
# 用 in 判断字典中是否有某个数据
print('stu1' in info) # info.has_key("1103") 仅存在python2.x

# 合并(合并过程中有相同key的values将会被后者的values覆盖)
b = {1:2,3:4,'stu1':"tom"}
info.update(b)
# info.setdefault("stu4",{"maray":[1,2]}) # 多级字典中去字典中找“stu4”，如果有取出，如果没有新建并将后面的key：values写入
# info.key() # 打印 key
# info.values() # 打印 values
# info.items() # 打印字典key-values
# 初始化一个新的字典(尽量少用)
c = dict.fromkeys([6,7,8],"test") # 把一个列表变成字典
print(c)

多级字典的嵌套
key 尽量不要用中文

字典的循环
for i in info:
print(i,info[i])
或者
for k,v in info.items():
print(k,v)
# 前者更高效，后者要先把字典转换成列表，效率较低

扩展阅读：https://www.cnblogs.com/whatisfantasy/p/5956761.html

# 字典与字符串互换
# strs to dict
strs = {'1000': {'2001': {'quantity': 1}, '2002': {'quantity': 2}}}
# 方法一
dict = eval(strs)
# 方法二
improt josn
dict = josn.loads(strs)
# dict to strs
只有用 josn
strs = josn.dumps(dict)

32 集合的使用
set 特性1 ：集合同字典是无序的
set 特性2 ：去同，set 里面没有重复的元素
set 特性3 ：关系测试

set_1=set([1,3,4,5,6,7,9])
set_2=set([0,2,66,4,6,8,22])
set_3=set([1,3,7])
set_4=set([5,6,8])
# 交集
print(set_1.intersection(set_2))
print(set_1 & set_2)
# 并集
print(set_1.union(set_2))
print(set_2 | set_1)
# 差集
print(set_1.difference(set_2))
print(set_1 - set_2)
# 判断是否是子集
print(set_1.issubset(set_2))
print(set_1 <= set_2)
# 判断是否是父集
print(set_1.issuperset(set_2))
print(set_1 >= set_2)
# 对称差集(把两个列表所有元素中交集部分去掉后的元素)
print(set_1.symmetric_difference(set_2))
print(set_1 ^ set_2)
# 判断两个list是否有交集，没有返回真
print(set_3.isdisjoint(set_4))

# 集合的操作
# 添加集合无插入
set_1.add(999)
set_1.update([10,37,42]) #插入多项
# 任意删除
set_1.pop() # 删除默认的最后一个元素，并返回该元素的值
# 指定删除,(如果元素不存在会报错)
set_1.remove(6)
# 指定删除,(如果元素不存在不会报错，且不返回被删除元素)
set_1.discard(6)

33 文件操作
f = open("yesterday",‘r’,encoding="utf-8") # 文件句柄(读模式)
data = f.read() # 读完整文件
data2 = f.readline() # 读一行
data2 = f.readlines() # 读所有行，每行为一个列表的元素
print(data) # 打印文件
f = open("yesterday2",‘w’,encoding="utf-8") # 文件句柄(写模式)"此模式会创建一个文件"
f.write("我爱北京\n")
f.write("我爱中国")
f.close # 关闭文件
f = open("yesterday2",‘a’,encoding="utf-8") # 文件句柄(追加模式)
f.write("我爱地球")

35 文件操作之增删查改
print(f.tell()) # 返回文件指针位置，按字符计数
print(f.readline()) # 读一行返回一行的值
print(f.readlines()) # 全部读出，返回一个list，每行视为一个元素
print(f.tell())
# 操作文件指针
f.seek(10) # 文件指针回到 10 字符位置,默认参数为 0
# 打印文件编码
print(f.encoding) # 打印文件编码
# 返回文件句柄在内存中的编号
print(f.fileno) # 返回操作系统打开文件的编号
# 刷新(将buffer强制写入硬盘)
f.flush
#示例
# 打印进度条
improt sys,time
for in range(50)
sys.stdout.write("#") # sys.stdout 标准输出
sys.stdout.flush() # 强制写入硬盘
time.sleep(0.1) # 延后 0.1 秒写入
# 截断
f.truncate(20) # 从文件头部开始到指针位置向后“20”个字符的位置截断文件
# 文件修改
line.replace() # 文件内容替换(修改文件思路：读一行，改一行，写一行)
# 文件打开方式
f = open("yesterday",‘r+’,encoding="utf-8") # 文件句柄(读写加模式)
f = open("yesterday",‘w+’,encoding="utf-8") # 文件句柄(写读模式---实际会先创建文件)
f = open("yesterday",‘a+’,encoding="utf-8") # 文件句柄(追加读模式)
f = open("yesterday",‘rb’) # 文件句柄(二进制模式读，而进制不能编码)
f = open("yesterday",‘wb’) # 文件句柄(二进制模式写)
# 示范
f.write("hello binary\n",encode()) # encode()没有参数默认用系统编码
f.close()
# 补充说明
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
# 04分，修改文件示例
# wiht 语句
whit 语句执行完会自动关闭文件
with 在python 2.7后可以同时打开多个文件。
# 示例
with open("yesterday2","r",encoding="utf-8") as f ,\
open("yesterday2","r",encoding="utf-8") as f2:
for line in f:
print(line)

38 字符转编码操作
# 打印系统默认编码
improt sys
print(sys.getdefaultencoding())
# 解码 & 编码
s = "你好"
s_to_unicode = s.encode("utf-8") # 解码，留空为系统默认编码
print(s_to_unicode,type(s_to_unicode))
s_to_gbk = s_to_unicode.encode("gbk") # 编码，留空为系统默认编码
print(s_to_gbk)

40 函数介绍
# 三种编程方式：
面向对象
面向过程
面向函数
# 函数编程的好处
省略重复功能的代码
易于修改和扩展
易于保持一致性
# 函数返回值
返回值数 =0 ：返回 None
返回值数 =1 ：返回对象
返回值数 >1 ：返回元祖
# 形参 & 实参
位置参数必须在关键字参数之前
# 默认参数特点
如果有默认参数的话，调用函数的时候，可以不用传递参数

41 函数的非固定参数
# 函数组...实例(*args) (把n个位置参数，变成元组形式
def test(*args):
print(args)

test(1,2,3,4,5)
test(*[1,2,3,4,5]) # args=tuple([1,2,3,4,5])

# 函数组...实例(**kwargs) (把n个关键字参数，变成字典形式)
def test2(**kwargs):
print(kwargs)

test2(name='alex',age=8,sex="F")
test2(**{'name':'alex','age':8,'sex':"F"})

# *参数定义的顺序必须是：
必选参数 > 默认参数 > 可变参数/命名关键字参数 > 关键字参数

posted on 2017-02-20 17:24 beetalker 阅读(239) 评论(0) 收藏举报

刷新页面返回顶部

公告

导航