一，开发语言介绍
高级语言：Java，C#，Python ==》产生字节码
低级语言：C，汇编 ==》产生机器码
高级语言开发效率高，低级语言运行效率高
Python种类：
JPython
IronPython
JavaScriptPython
RubyPython
CPython **********
pypy 这是用CPython开发的Python
二，Python文件执行的条件
1，解释器指定
Windows系统中
D:\python35\python 2.py
Linux系统中
如果使用./2.py则在文件内部需要指定Python解释器
#!/usr/bin/python 或者 #!/usr/bin/python2.7
并给执行权限
chmod 755 2.py
2，字符编码指定
# -*- coding:utf8 -*-
只对python2有效，python2默认使用ASC码对照表解释
ascill 00000000
& 00000001
unicode 0000000000000000+
& 0000000000000001
中 001000000000000111110010
utf-8 能用多少表示就是用多少表示，表示汉字用3字节
& 00000001
中 001000000000000111110010
gbk使用2个字节
三，Python基础
（一）变量
变量作用是记录状态
1，变量名
- 字母
- 数字
- 下划线
PS：
数字不能开头
不能是关键字
最好不要和python内置的东西重复 ***
name = "石正文"
2，变量基本类型
字符串
数字
列表
元组
字典
3，可变不可变
1），可变：修改变量的值，id值不变。列表，字典
2），不可变：新建立变量后需要开辟新内存地址。字符串，数字，元组
4，访问顺序
1），顺序（序列对象）：字符串，列表，元组
2），映射：字典
3），直接：数字
5，存放元素个数
容器类型：列表，元组，字典
原子：数字，字符串
（二）控制结构
1. 条件语句：缩进用4个空格
a.
n1 = input('>>>')
if "alex" == "alex":
n2 = input('>>>')
if n2 == "确认":
print('alex SB')
else:
print('alex DB')
else:
print('error')
注意：
n1 = "alex" 赋值
n1 == 'alex' 比较，
b.
if 条件1：
pass
elif 条件2:
pass
elif 条件3:
pass
else:
pass
print('end')
c. 条件1
and or
if n1 == "alex" or n2 == "alex!23":
print('OK')
else:
print('OK')
PS:
pass 代指空代码，无意义，仅仅用于表示代码块
2.while循环语句
while 条件：
....
print('...')
补充：
a. while else
b. continue break
continue ,终止当前循环，开始下一次循环
break ,终止所有循环
count = 0
s = 0 while count < 10:
if count != 7:
print (count)
count = count + 1
print('----end----') count = 1
while count < 101:
s = count + s
count = count +1
print(s)
print('----end----') count = 1
while count < 101:
if count%2 == 1:
print(count)
else:
pass
count = count + 1 print('----end----') count = 1
while count < 101:
if count%2 == 0:
print(count)
else:
pass
count = count + 1 print('----end----') count = 1
s = 0
while count < 101:
if count%2 == 0:
s = s - count
else:
s = s + count
count = count + 1
print(s)
print('----end----')
（三）运算符
结果是值
算数运算
a = 10 * 10
赋值运算
a = a + 1 a+=1
结果是布尔值
比较运算
a = 1 > 5
逻辑运算
a = 1>6 or 1==1
成员运算
a = "蚊" in "郑建文"
（四）基本数据类型
字符串 - n1 = "alex" n2 = 'root' n3 = """eric""" n4='''tony'''
数字 - age=21 weight = 64 fight = 5
数字：
n1 = 9
n2 = 2
n3 = n1 + n2
n3 = n1 - n2
n3 = n1 * n2
n3 = n1 / n2
n3 = n1 % n2
n3 = n1 ** n2
数字 int ，所有的功能，都放在int里
a1 = 123
a1 = 456
- int
将字符串转换为数字
a = "123"
print(type(a),a)
b = int(a)
print(type(b),b)
num = "0011"
v = int(num, base=16)
print(v)
- bit_lenght
# 当前数字的二进制，至少用n位表示
r = age.bit_length()
num = 12
n = num % 2
if n == 0:
print('偶数')
else:
print('奇数')
字符串：
加法：
n1 = "alex"
n2 = "sb"
n4 = "db"
n3 = n1 + n2 + n4
# "alexsbdb"
乘法：
n1 = "alex"
n3 = n1 * 10
字符串 str
s1 = "asdf"
s2 = "asdffas"
字符串的魔法
小技巧：输入关键字，使用CTRL加鼠标左键单击，跳转到源码，进一步就可以看到方法的声明，然后学习相应的方法。（适用于所有的语言）
#首字母大写
test = "aLex"
v = test.capitalize()
print(v) # 所有变小写，casefold更牛逼，很多未知的对相应变小写
v1 = test.casefold()
print(v1)
v2 = test.lower()
print(v2) # 设置宽度，并将内容居中
# 20 代指总长度
# * 空白未知填充，一个字符，可有可无
v = test.center(20,"中")
print(v)
# 左右对齐
test = "alex"
v = test.ljust(10,"*")
print(v)
v = test.rjust(10,"_")
print(v)
v = test.zfill(10)
print(v)
# 去字符串中寻找，寻找子序列的出现次数
test = "aLexalexr"
v = test.count('ex')
print(v) test = "aLexalexr"
v = test.count('ex',5,6)
print(v) # 欠
# encode
# decode # 以什么什么结尾
# 以什么什么开始
test = "alex"
v = test.endswith('ex')
v = test.startswith('ex')
print(v) # 以expandtabs里的数字为一组，使用\t补全该组
test = "12345678\t9"
test1 = "username\temail\tpassword\nlaiying\tying@email.com\t123"
v = test.expandtabs(6)
v1 = test1.expandtabs(20)
print(v,len(v))
print(v1) # 从开始往后找，找到第一个之后，获取其位置
# > 或 >=
test = "alexalex"
# 未找到 -1
v = test.find('ex')
print(v) # index找不到，报错 忽略
test = "alexalex"
v = test.index('')
print(v) # 格式化，将一个字符串中的占位符替换为指定的值
test = 'i am {name}, age {a}'
print(test)
v = test.format(name='alex',a=19)
print(v) test = 'i am {0}, age {1}'
print(test)
v = test.format('alex',19)
print(v) # 格式化，传入的值 {"name": 'alex', "a": 19}
test = 'i am {name}, age {a}'
v1 = test.format(name='df',a=10)
v2 = test.format_map({"name": 'alex', "a": 19}) # 字符串中是否只包含 字母和数字
test = ""
v = test.isalnum()
print(v)
#是否包含字母，汉字
test = "asdf2"
v = test.isalpha()
print(v) #是否是数字,isdecimal十进制-》isdigit包含特殊字符数字①-》isnumeric能识别大写的“二”
test ="①"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3) # 符合标识符规则就行，不能以数字开头
test ="class"
v = test.isidentifier()
print(v) #是否存在不可显示的字符\t \n
test ="ssn\tdd"
v = test.isprintable()
print(v) #判断是否全部是空格
test =" "
v = test.isspace()
print(v) #每个词的首字母都大写，成为标题
test = "A is For Anna"
v = test.istitle()
print(v)
v2 = test.title()
print(v2)
v3 = v2.istitle()
print(v3) #*****字符串的每一个字符使用指定分隔符进行拼接
test ="你是风儿我是沙"
print(test)
t =' '
v = t.join(test)
print(v)
#判断是否全部是大小写，转换成大小写
test = "Alex"
v1 = test.islower()
v2 = test.lower()
print(v1,v2) v1 = test.isupper()
v2 = test.upper()
print(v1,v2) #去除空格及不可见字符\t \n,指定内容可以把指定内容去掉，有限最多匹配
test = "\nalex "
print(test)
v = test.lstrip()
print(v)
v = test.rstrip()
print(v) test = "xalex "
print(test)
v = test.lstrip(‘9lexex’)
print(v) # 对应替换
test = "你是风儿我是沙"
test1 = "去你妈的风河沙"
v = "你是风儿我是沙 334"
m = str.maketrans(test,test1)
new_v = v.translate(m)
print(new_v) # 如果能分割，分割成三份
test = "testasdsddfg"
v = test.partition('s')
print(v)
v = test.rpartition('s')
print(v)
# 全部分割，或者指定分割次数，但取不到分隔符
v = test.split('s',2)
print(v)
v = test.rsplit('s',2)
print(v) #只能根据换行分割，True,False用来指定保留换行符\n
test = "asdfasdf\nasdfasdf\nasdf"
v = test.splitlines(True)
print(v) #以X开头，以X结尾
test = "backend 1.1.1.1"
v = test.startswith('B')
print(v)
v = test.endswith('')
print(v) #大小写转换
test = "aLEx"
v = test.swapcase()
print(v)
#将指定字符串替换为指定字符串
test = "alexalexalex"
v = test.replace("ex",'bbb')
print(v)
v = test.replace("ex",'bbb',2)
print(v)
公共子序列
“alex”和“uilex”的公共子序列是“lex”
###################### 7个基本魔法 ######################
# join # '_'.join("asdfasdf") 可以用于其它数据类型
# split
# find
# strip
# upper
# lower
# replace
###################### 5个灰魔法 #####################
test = "郑建文妹子有种冲我来"
# 一、for循# for 变量名 in 字符串:
# 变量名
# break
# continue index = 0
while index < len(test):
v = test[index]
print(v)
index += 1 print('=======') for zjw in test:
print(zjw) test = "郑建文妹子有种冲我来"
for item in test:
print(item)
break for item in test:
continue
print(item) # 二、索引，下标，获取字符串中的某一个字符
v = test[3]
print(v) # 三、切片
v = test[0:-1] # 0=< <1
print(v) # 四、获取长度
# Python3： len获取当前字符串中由几个字符组成
v = len(test)
print(v)
#计算列表里面元素个数
li = [11,22,33,44,55]
len(li)
# 注意：在其他数据类型中下面这些操作一样可以用
# len("asdf")
# for循环
# 索引
# 切片 # 五、range()获取连续或不连续的数字，
# Python2中直接创建在内容中
# python3中只有for循环时，才一个一个创建
# r1 = range(10)
# r2 = range(1,10)
# r3 = range(1,10,2)
# 帮助创建连续的数字,通过设置步长来指定不连续
# v = range(0, 100, 5)
#
# for item in v:
# print(item)
# 练习题：根据用户输入的值，输出每一个字符以及当前字符所在的索引位置
test = input(">>>")
for item in test:
print(item) # 将文字 对应的索引打印出来：
test = input(">>>")
print(test) # test = qwe test[0] test[1]
l = len(test) # l = 3
print(l) r = range(0,l) # 0,3
for item in r:
print(item, test[item]) # 0 q,1 w,2 e test = input(">>>")
for item in range(0, len(test)):
print(item, test[item])
###################### 1个深灰魔法 ######################
# 字符串一旦创建，不可修改
# 一旦修改或者拼接，都会造成重新生成字符串
name = "zhengjianwen"
age = "" info = name + age
print(info)
做练习题补漏
#1，在切片里面，-1代表最后一个位置，因此下面输出rooted。-2代表倒数第二个位置
name = "rootedd"
print(name[1:-1]) #2，只要一个对象能执行
for i in 值
print(i)
就可以称为可迭代对象 #3，类，类型
str 是一个类型，bool是一个类型
a1 = “alex” a1是一个对象 #4，range用法
#在python2还有一个xrange()，相当于python3里面的range，for循环的时候才一个一个创建。 #从100 到0，注意步长为-1
for i in range (100,0,-1):
print(i) #5，Pycharm 有reformat代码的功能
列表 list
###################### 魔法，list类中提供的方法 ######################
#1,原来值后追加
li = [11,22,33,44]
v = li.append(5)
print(v)
print(li)
li.append([1234,5678])
print(li) #2，清空列表
li.clear()
print(li) #3,浅拷贝
li = [11,22,33,"","alex"]
v = li.copy()
print(v) #4，计算元素出现的次数
v = li.count("")
print(v) #5, 扩展原来的列表，参数是可迭代对象，与append区别是，append把参数当成整体添加，extend则拆解添加
li = [11,22,33,22,44]
li.extend([9898,"不得了"])
print(li)
li.extend("下雨了")
print(li) #6，根据值获取当前值索引位置（左边优先）
li = [11,22,33,22,44]
v = li.index(22,2)
print(v) #7，在指定索引位置插入
li = [11,22,33,22,44]
li.insert(0,99)
print(li) #8，删除某个值(可以指定索引，默认是最后一个),并获取删除值
li = [11,22,33,22,44]
v = li.pop(1)
print(li)
print(v)
#删除列表中的指定值，左边优先
li = [11,22,33,22,44]
li.remove(22)
print(li)
#删除方法汇总 1,pop 2,remove 3,del li[0] 4,del li[7:9] 5，clear #9，将当前列表进行反转
li = [11,22,33,22,44]
li.reverse()
print(li) #10,列表的排序
li = [11,22,33,22,44]
li.sort(reverse=True)
print(li)
#欠 cmp key sorted #字符串和列表的区别:字符串创建之后不能修改
v = "alex"
v = v.replace('l','el')
print(v)
#产生新的字符串 li = [11,22,33,44]
li[0]#索引取值
li[0] = 999 #索引修改 s = "alex"
print(s[0]) #索引取值
s[0] = "E" #索引不能修改
print(s)
###################### 深灰魔法######################
#1，列表怎么写：中括号括起来，使用逗号分割，列表中的元素可以是数字,字符串,列表,布尔值,所有的都能放进去，
#2，可以嵌套
#列表的数学抽象就是一个"集合" li = [1,12,9,"age",["市政",["",10],"旁买了"],"alex",True] #3，索引取值
print(li[3])
#嵌套情况取值
print(li[4][1][0]) #4，切片,切片结果也是列表
print(li[3:5]) #5，for,while 循环
# for item in li:
# print(item) #6，索引
#索引修改
li[1] = 120
print(li)
li[4] = [11,22,33,44]
print(li) #索引删除
del li[4]
print(li) #7，切片
#切片修改
li[0:3] = [1,2,3]
print(li) #切片删除
li2 = [1,12,9,"age",["市政","旁买了"]]
del li2[2:3]
print(li2) #8，查找 in操作
li3 = [1,12,9,"age",["市政","旁买了"]]
v = "市政" in li3[4]
print(v) #9,字符串可以转列表（内部使用for循环），数字不能for循环，不能转换列表
s = "12eewdsd"
new_li = list(s)
print(new_li)
#列表转换成字符串
#如果列表里有字符串和数字的混合，只能使用for循环来转换
li = [11,22,33,"","alex"]
print(li)
r = str(li)
print(r) s = ""
for i in li:
s = s + str(i)
print(s) #如果列表里只有字符串,则可以使用join简单处理
li = ["","alex"]
v = "".join(li)
print(v)
元祖 tuple
###################### 魔法 ######################
#tu.count(22)，获取指定元素在元组中出现的次数
#tu.index(22)，获取某一个值的索引位置
###################### 深灰魔法######################
#1,元组是对列表的二次加工，元组的一级元素不可被修改，不能被增加或者删除
#一般写元组的时候，推荐在最后加入逗号
li = [111,22,33,44]
tu =(111,22,33,44,)
#2,索引
v = tu[0]
print(v)
#3,切片
v = tu[0:2]
print(v) #tu[0] = 123 # 不能修改
#del tu[0] # 不能删除
#4,可以被for循环，可迭代对象（字符串，列表，元组都是可迭代对象）
for item in tu:
print(item) #5,转换
s = "asdfasdf0"
li = ['asdf',123]
tu = (123,123,"asdf") v = tuple(s) #字符串转元组
print(v) v1 = tuple(li)#列表转元组
print(v1) v2 = list(tu)#元组转列表
print(v2) #如果元组里面只有字符串,使用join转换
tu = ("","asdf")
v = "_".join(tu)
print(v) #可迭代对象可以使用extend
li = ["asdf","assdfasdf"]
li.extend((11,22,33,))
print(li) #6，元组也是有序的,元组里面的列表是可以修改的
tu = (111,"alex",(11,22),[(33,44)],True,33,44)
v = tu[3][0][0]
print(v)
#tu[0] = 123
tu[3][0]= 567
print(tu)
字典 dict
###################### 魔法 ######################
dt ={}
dt.clear()
dt.copy() #浅拷贝
#静态方法 直接使用类名执行方法
#@staticmethod # known case
#def fromkeys(*args, **kwargs): # real signature unknown
#1，根据列表，创建字典，并指定统一值
v = dict.fromkeys(["k1",123,""],123)
print(v)
#2，get取值方法
dic = {
"k1":"v1",
"k2":"v2"
}
#v = dic['k11111']
#如果键值不存在则报错
#print(v)
#使用get方法就不报错,而返回None,也可以指定返回值
v = dic.get('k111',"asdfasdf")
print(v)
#3，pop方法删除并获取值 ,如果对应键没有，也可以返回设定的返回值
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.pop("k11",90)
print(v,dic)
#popitem 随机删除
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.popitem()
print(v)
#4，setdefault,如果键存在则不进行设置返回键的原有值；如果键不存在，则添加一个键值对
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.setdefault('k111','')
print(dic,v)
#5，更新
dic = {
"k1":"v1",
"k2":"v2"
}
v = dic.update({'k1':'','k3':''}) #传值传字典
print(dic)
dic.update(k1=123,k2=345,k3=456) #如果在函数中把参数名写成**，则会把参数自动转换成字典
print(dic)
#字典里面最常用的是keys(),values(),items(),get(),update()
###################### 深灰魔法######################
#1，字典 dict基本结构
info ={
"k1":"v1", #键值对
"k2":"v2"
} #2，字典的value可以是任何形式
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}
print(info) #3，列表和字典不能作为字典的key
#布尔值可以作为key，但要注意和0，1重复的问题
info = {
1:'asd',
"k1":'asdf',
True:"",
#[11,22]:123,
(11,22):123,
#{'11':'22'}:123,
} #4，通过打印可以知道字典是无序的 #5，索引方式(key)找到指定元素
v = info["k1"]
print(v)
v = info[1]
print(v)
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}
#找到kk3里面的的11
v = info["k3"][3]["kk3"][0]
print(v)
#字典不能通过切片方式找 #6，del删除
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
}
print(info)
del info["k1"]
print(info)
del info["k3"][3]["kk1"]
print(info) #7，字典支持for循环
info ={
"k1":18,
"k2":True,
"k3":[
11,
22,
33,
{'kk1':'vv1',
'kk2':'vv2',
'kk3':(11,22),
}
],
"k4":(11,22,33,44)
} for item in info:
print(item) for item in info.keys():
print(item) for item in info.values():
print(item) for k,v in info.items():
print(k,v)
布尔值 bool
# 0 1
# bool(...)
# None "" () [] {} 0 ==> False
####################### 整理 ################# # 一、数字
# int(..)
# 二、字符串
# replace/find/join/strip/startswith/split/upper/lower/format
# tempalte = "i am {name}, age : {age}"
# # v = tempalte.format(name='alex',age=19)
# v = tempalte.format(**{"name": 'alex','age': 19})
# print(v)
# 三、列表
# append、extend、insert
# 索引、切片、循环
# 四、元组
# 忽略
# 索引、切片、循环 以及元素不能被修改
# 五、字典
# get/update/keys/values/items
# for,索引 # dic = {
# "k1": 'v1'
# } # v = "k1" in dic
# print(v) # v = "v1" in dic.values()
# print(v)