（本章内容：开放工具，格式化输出，数据运算，for/while循环，文件操作）
一、 开发工具
- IDE集成开发环境（IDE，Integrated Development Environment ）
例：①VIM ： linux下经典的的文本编辑器
②Emacs ：linux文本编辑器，比VIM更友好
③Eclipse ：Java IDE，支持python,c,c++等语言（插件）
④Visual Studio ：微软windows开发的IDE，支持python,c++,java,c#
⑤notepad++
⑥sublime ：python开发的，与notepad++差不多
⑦Pycharm ：主要用于python开发的IDE
1. Pycharm
①New Project—》建立项目名
Pure Python：纯Python项目
Django、Flask、Pyramid、Web2Py：web框架，做网站
Google App Engine ：google app 开发
Angular CLI、AngularJS：web前端框架
②建立文件夹。建立python文件。
new--》python file
③打开工具栏：最上面ViewàToolbar
④改字体：工具栏—》setting—》Editor—》Font
⑤快捷键：Ctrl + /：注释(取消注释)选择的行
Ctrl + Enter：在下方新建行但不移动光标
Shift + Enter：在下方新建行并移到新行行首
Ctrl+d：对光标所在行的代码进行复制
2. 代码模板
setting--》Editor--》File and Code Templates --》 python Script
#_author: ${USER}
#date : ${DATE}
二、 格式化输出
- 占位符：放置变量
%s s = string
%d d = digit 整数
%f f = float 浮点数，约等于小数
例：name = input("Name:")
age = input("Age:")
output = '''
Name:%s
Age:%s
'''%(name,age)
print(output)
判断输入是否为数字：
if age.isdigit():
age = int(age) #强制转换
else:
print(“请输入数字”)
三、 数据运算
- 数据类型
①数字
②整型int(integer)
整型、长整型
在python3 已经不区分整型与长整型，统一都叫整型
③布尔 只有2种状态，分别是
真 True
假 False
④字符串
a="Let's go "
# * 重复输出字符串
#print('hello'*20)
# [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
# print('helloworld'[2:])
#关键字 in
# print(123 in [23,45,123])
# print('e2l' in 'hello')
# % 格式字符串
# print('alex is a good teacher')
# print('%s is a good gir;'%zhi')
#添加
#a='123'
# b='abc'
# c=a+b
# #
# c= ' '.join([a,b])
# print(c)
# String的内置方法
# st='hello kitty {name} is {age}'
#
# print(st.count('l')) # 统计元素个数
# print(st.capitalize()) # 首字母大写
# print(st.center(50,'#')) # 居中
# print(st.endswith('tty3')) # 判断是否以某个内容结尾
# print(st.startswith('he')) # 判断是否以某个内容开头
# print(st.expandtabs(tabsize=20))
# print(st.find('t')) # 查找到第一个元素，并将索引值返回
# print(st.format(name='alex',age=37)) # 格式化输出的另一种方式 待定：?:{}
# print(st.format_map({'name':'alex','age':22}))
# print(st.index('t')) #与find相同，查找元素的索引值
# print('asd'.isalnum()) #判断字符串是不是一个包含数字和字母的字符串
# print('12632178'.isdecimal()) #判断是否是一个十进制的数
# print('1269999.uuuu'.isnumeric()) #与decimal相同
# print('abc'.isidentifier()) #判断是否是非法标识符
# print('Abc'.islower()) #判断是否全为小写
# print('ABC'.isupper()) #判断是否全为大写
# print(' e'.isspace()) #判断是否是空格
# print('My title'.istitle()) #判断是否为标题（首字母大写）
# print('My tLtle'.lower()) #大写变小写
# print('My tLtle'.upper()) #小写变大写
# print('My tLtle'.swapcase()) #大小写反转
# print('My tLtle'.ljust(50,'*')) #与center一致，向左边
# print('My tLtle'.rjust(50,'*')) #向右边
# print('\tMy tLtle\n'.strip()) #去掉空格和换行符
# print('\tMy tLtle\n'.lstrip()) #去掉左边的空格和换行符
# print('\tMy tLtle\n'.rstrip()) #去掉右边的空格和换行符
# print('ok')
# print('My title title'.replace('itle','lesson',1)) #替换
# print('My title title'.rfind('t')) #从右往左寻找
# print('My title title'.split('i',1)) #以i为分割
# print('My title title'.title()) #变成标题模式
#摘一些重要的字符串方法
#1 print(st.count('l'))
# print(st.center(50,'#')) # 居中
# print(st.startswith('he')) # 判断是否以某个内容开头
# print(st.find('t'))
# print(st.format(name='alex',age=37)) # 格式化输出的另一种方式 待定：?:{}
# print('My tLtle'.lower())
# print('My tLtle'.upper())
# print('\tMy tLtle\n'.strip())
# print('My title title'.replace('itle','lesson',1))
# print('My title title'.split('i',1))
⑤列表，元组
a=[‘aa’,’bb’,’cc’,’dd’,’ee’]
a=list()
print(list[1])
1）增删查改
# 查 切片
a[1:4]
a[1:-1] #取到倒数第二个值
a[1:] #取到最后
a[1:-1:1] #从左到右一个一个的去取 (list[3::-1]从右往左)
a[1::2] #从左到右隔一个的去取
#增
a.append() 追加
a.insert(index, "内容")
a.extend 扩展
#改
a[index] = "新的值"
a[start:end] = [a,b,c]
#删
remove("内容")
pop(index)
del a, del a[index]
a.clear() 清空
2) 列表内置方法
.conut：计算某个元素出现次数
.index 根据内容找其对应的位置
排序：
sort ()
reverse() 倒序
3）深浅拷贝
.copy() #拷贝
不可变数据类型:数字,字符串,元组
可变类型:列表,字典
# 当你对可变类型进行修改时,比如这个列表对象l,它的内存地址不会变化,注意是这个列表对象l,不是它里面的元素
#像不可变数据类型,是不能修改的,比如我想要一个'All'的字符串,只能重新创建一个'All''的对象,然后让指针只想这个新对象
浅拷贝：只拷贝一层 #copy.copy(对象)
深拷贝：克隆一份 #copy.deepcopy(对象)
元组
a=(a,b,c)
a = (20,) # 一个元素，需要在元素后添加逗号
⑥字典
无序，键唯一
#创建字典方法 dic={'name':'liz'}
# dic=dict( ( ('name','zhi')， ) )
dic =dict( [ [ ] ] )
print(dic['name'])
字典的操作
#增
dic1={'name':'zhi'}
dic1['age']=18
键存在，不改动，返回字典中相应的键对应的值
键不存在，在字典中中增加新的键值对，并返回相应的值
ret=dic1.setdefault('age',18)
setdefault有返回值
#查
通过键去查找
print(dic['name'])
print(list(dic.keys())) #查看字典中有哪些键
print(list(dic.values())) #查看字典中有哪些值
print(list(dic.items())) #查看所有的键值对
#改
dic={'age': 18, 'name': 'zhi', 'hobby': 'draw'}
dic['age']=50
dic1={'2':'11','name':'233'}
dic.update(dic1) #将dic1放入dic中，重复则覆盖
#删
dic.clear() # 清空字典
del dic['name'] #删除字典中指定键值对
print(dic.pop('age')) #删除字典中指定键值对，并返回该键值对的值
a = dic.popitem() #随机删除某组键值对，并以元组方式返回值
del dic #删除整个字典
#其他操作以及涉及到的方法
1.给键统一赋值 .fromkeys
dic2=dict.fromkeys(['host1','host2','host3'],'test')
print(dic2) #{'host3': 'test', 'host1': 'test', 'host2': 'test'}
dic2=dict.fromkeys(['host1','host2','host3'],['test1','tets2'])
print(dic2) #{'host2': ['test1', 'tets2'], 'host3': ['test1', 'tets2'], 'host1': ['test1', 'tets2']}
dic2['host2'][1]='test3'
print(dic2) #{'host3': ['test1', 'test3'], 'host2': ['test1', 'test3'], 'host1': ['test1', 'test3']}
2.字典的复制 .copy
3.字典的嵌套
字典中可嵌套列表、字典
4.排序
print(sorted(dic)) #根据key排序
print(sorted(dic.items()))
print(sorted(dic.values()))
5.字典的遍历
for i in dic:
print(i) #遍历键
for i in dic:
print(i,dic[i]) #遍历键和值【推荐方法】
for i in dic.items():
print(i) #输出以元组的形式
for i,v in dic.items():
print(i,v)
⑦集合（set）
集合一个无序的，不重复的数据组合，主要作用：
1.去重，把一个列表变成集合，就自动去重了
2.关系测试，测试两组数据之前的交集、差集、并集等关系
创建集合：
s=set（）
集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键
集合分类：可变集合、不可变集合
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
##可哈希（hashable）和不可改变性（immutable）
如果一个对象在自己的生命周期中有一哈希值（hash value）是不可改变的，那么它就是可哈希的（hashable）的，因为这些数据结构内置了哈希值，每个可哈希的对象都内置了__hash__方法，所以可哈希的对象可以通过哈希值进行对比，也可以作为字典的键值和作为set函数的参数。所有python中所有不可改变的的对象（imutable objects）都是可哈希的，比如字符串，元组，也就是说可改变的容器如字典，列表不可哈希（unhashable）。我们用户所定义的类的实例对象默认是可哈希的（hashable），它们都是唯一的，而hash值也就是它们的id()。
集合的相关操作
1.创建集合
s1 = set('yi')
s2= frozenset('yuan')
print(s1,type(s1)) #{'y', 'i'} <class 'set'>
print(s2,type(s2)) #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>
2.访问集合
由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。
for i in s1:
print(i)
3.更新集合
s.add()
s.update()
s.remove()
注意：只有可变集合才能更新
del：删除集合本身
集合类型操作符
1 in ,not in
2 集合等价与不等价(==, !=)
3 子集、超集
s=set('yiyuan')
s1=set('yi')
print('i' in s) #TRUE
print(s1<s) #TRUE
4 联合(|)
联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()
s3=s1|s2
print(s1.union(s2))
5、交集(&)
与集合and等价，交集符号的等价方法是intersection()
s3=s1&s2
print(s1.intersection(s2))
6、差集(-)
等价方法是difference()
s3=s1-s2
print(s1.difference(s2))
7、对称差集(^)
对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()
s3=s1^s2
print(s1.symmetric_difference(s2))
应用
'''最简单的去重方式'''
lis = [1,2,3,4,1,2,3,4]
print list(set(lis)) #[1, 2, 3, 4]
四、 for、while循环（loop）
1. continue 结束本次循环，继续下一次循环
break 跳出整个当前的循环
2. for循环 [有限循环]
例：输入三次的循环可以使用
for I in range(3):
print(i)
注：range为范围函数，其他用法：range(1,101)，range(1,101,2) #2为步长
3. while [无限循环]
while True:
4. 程序断点：点击代码行左端出现的红点，使程序一步一步往下走
运行：Debug调试模式
五、文件操作
能调用方法的一定是对象
open()函数找到文件对象
close（）关闭文件
read（）读
write（）写
f = open('文件名', '模式',encoding='utf-8') #模式有r读和w写
data = f.read()
print(data)
f.close()
1.文件打开模式
先介绍三种最基本的模式：
# f = open('小重山2','w') #打开文件
# f = open('小重山2','a') #打开文件
# f.write('莫等闲1\n')
# f.write('白了少年头2\n')
# f.write('空悲切!3')
f.readline（） #输出一行内容
for i in f.readlines():
print(i).strip() #去掉空格
打开文件最优方式：
for i in f:
print(i.strip())
count=0
for line in f:
if count==3:
line=''.join([line.strip(),'end 3'])
print(line.strip())
count+=1
print(f.tell()) #tell对于英文字符就是占一个,中文字符占三个,区分与read()的不同.
print(f.read(5)) #一个中文占三个字符
f.seek(0)
print(f.read(6)) #read后不管是中文字符还是英文字符,都统一算一个单位,read(6),此刻就读了6个中文字符
# #二进制模式
f = open('小重山2','wb') #以二进制的形式读文件
f = open('小重山2','wb') #以二进制的形式写文件
f.write('hello alvin!'.encode())#b'hello alvin!'就是一个二进制格式的数据,只是为了观看,没有显示成010101的形式
##seek:
# test:
昨夜寒蛩不住鸣.
f = open('test','rb',) #以写读模式打开文件
f.read(3)
#f.seek(3)
# print(f.read(3)) # b'\xe5\xa4\x9c'
# f.seek(3,1)
# print(f.read(3)) # b'\xe5\xaf\x92'
# f.seek(-4,2)
# print(f.read(3)) # b'\xe9\xb8\xa3'
#总结: 在py3中,如果你想要字符数据,即用于观看的,则用r模式,这样我f.read到的数据是一个经过decode的
# unicode数据; 但是如果这个数据我并不需要看,而只是用于传输,比如文件上传,那么我并不需要decode
# 直接传送bytes就好了,所以这个时候用rb模式.
# 在py3中,有一条严格的线区分着bytes和unicode,比如seek的用法,在py2和py3里都是一个个字节的seek,
# 但在py3里你就必须声明好了f的类型是rb,不允许再模糊.
#建议: 以后再读写文件的时候直接用rb模式,需要decode的时候仔显示地去解码.
##with语句
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
| 1 2 | with open('log','r') as f: pass |
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：
| 1 2 | with open('log1') as obj1, open('log2') as obj2: pass |
本文参考博客：https://www.cnblogs.com/yuanchenqi/articles/5782764.html
2038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
