Python

1.输入和输出

print（）

input（）

2.条件语句

（1）　　

if   判断条件 ：

　　（条件成立则执行if下面的代码）

else：

　　（条件不成立则执行if下面的代码）

（2）   if语句支持嵌套

if  判断条件 ：

　　if 判断条件 ：

。。。。。

（3）if 支持多条件

if  判断条件 ：

　　（内部代码块）

elif 判断条件 ：

　　（内部代码块）

elif 判断条件 ：

　　（内部代码块）

。。。。。。

else：

　　（内部代码块）

3.关键字pass

pass表达的意思：什么都不执行

4.字符串（引号）

mane = ‘我是郑文’

mane = “我是郑文”

加法：n1 = "alex"     n2 = "sb"  n3=n1+n2 ="alexsb"

乘法：n1="alex"     n3=n1*10 ="lexlexlexlexlexlex..."

5.算术运算符（+ 、- 、* 、 / 、** （次方）、% （取余）、//（取商） ）

a2 = 2**4（表示2的4次方）

a3 = 39 // 8 ==4

成员运算符：in    not in  （判断某个东西是否在某个东西里面）

布尔值：True     false

比较运算符 ：（== 、<  、> 、 <=  、 >= 、（！= 、<>）不等于）

name="郑建文"
if '郑文' in name:
    print('True')
else:
    print('false')

逻辑运算符：and （与）、or （或）    判断顺序从左到右

6.变量（字母、数字、下划线）

（1）不能数字开头

（2）不能python的关键字

（3）不能重复变量名

7.循环语句  while 、for

while   循环条件：

　　循环模块

for  变量名  in  字符串：

　　循环模块

8.基本数据类型

（1）数字　　 int

a.字符串转换成数字：int

a = "123"
b =int(a)
print(a)

b.把二进制转换其他进制：base

num = "0011"
a = int(num,base=8)
print(a)

c.表示当前的数二进制用几位数 :bit_length

a = 100
r = a.bit_length()
print(r)

（2）字符串（一但创建就不可修改）　

注意：要牢记

 str  （join、split、find、upper、lower、replace）

a.通过索引方式获取字符串的字符：

test = "alex"
v = test[3]
print(v)

b.通过切片方式获取字符串的字符

test = "alex"
v = test[1:3]
print(v)

c.表示字符串长度：len

d.帮助创建连续的数，通过设置步长指定不连续：range（100） ==[0，100）

v = range(100)
print(v)
t= range(0,100,20)
for item in t:
    print(item)

字符串的功能： 

a.字母大写：capitalize （首字母）   upper（所有字母）

test = "alex"
v = test.capitalize()
print(v)

b.把大写变小写：casefold （可以处理很多字符，很少使用）、lower（处理英文，常用）

test = "aLex"
v1 = test.casefold()
print(v1)
v2 =test.lower()
print(v2)

c.设置宽度，并将内容居中：center 

test = "alex"
v= test.center(20,"*")
print(v)

 (ljust 左填充 、 rjust  右填充）

d.统计字符在字符串中出现次数：count  （可以指定位置统计）

test = "alexalsaa"
v= test.count('a')
print(v)

test = "alexalsaa"
v= test.count('a',4,9)
print(v)

e.判断以什么开始/结束：startswith /endswith

f.从左开始寻找字符在字符串中位置，获取其位置：find （可以指定寻找的位置）、index（寻找不到会报错）

t = "Alex"
v = t.find("e" ，1 ，4)
print(v)

g.格式化，将一个字符串中的占位符替换为指定的值：format

test = 'i am {name}, age {a}'
print(test)
v = test.format(name='alex',a=19)
print(v)

h.判断字符串中是否只包含 :isalnum（字母或数字）、isalpha（字母或汉字）、isdecimal/isdigit（数字）

test = "12366fhf"
v = test.isalnum()
print(v)

j.断句：expandtabs

test = "12345678\t9654"
v = test.expandtabs(9)
print(v)

k.标题：title（转换成标题）、istitle（判断是否是标题）

l.将字符串中的每个元素按照指定的分隔符进行拼接 ：jion

test = "你是风儿我是沙"
v = '_'.join(test)
print(v)

m.去除空格、/n 、/t：strip （也可以指定去除）

test = "qwewewqe"
v = test.strip('qw')
print(v)

n.分割:  partition(分成3分)  、split（可以指定的fenge）

test = "gjffujdhshfdsiuewr"
v = test.partition('s')
print(v)

t = "alelxklfhld"
v = t.split("l")
print(v)

o.代替replace 

t = "alelxklfhld"
v = t.replace("alel","Alex")
print(v)

。。。。。

（3）列表　　  list

a.列表格式

li = [1,22,33,["zhangsan","李四"],"小米","小红帽"]

b.列表可以嵌套任何类型

li = [1,22,33,["zhangsan","李四"],"小米","小红帽"]
for item in li:
    print(item)

c.通过索引的方式进行取值和修改、删除

取值：  m = li[2]   或者   n = li[1:4]

修改：li[1]=44   或者   li[1:3] = [77,99]

删除：del li[3]   或者   del li[4:6]

d.可以使用in判断列表的元素是否存在：in    （v = 22 in li）

e.字符串和列表相互转换

v = "asfjfkhdsg"
li = list(v)
print(li) 
注意：字符串中的每个字符在列表中都作为一个元素

li = [11,22,66,"cxz","lisi","小麦"]
s = ""
for i in li:
    s = s + str(i)
print(s)

注意：列表中有数字和字符串时，需要自己写for循环

li = ["cxz","lisi","小麦"]
v = "".join(li)
print(v)
注意：列表元素都是数字或者都是字符串

f. list的功能

A. 向列表增加元素：append / extend 在列表的后面追加）、 insert   （指定索引位置插入）         

li = [11,22,66,"cxz","lisi","小麦"]
li.append(5)
print(li)

li = [11,22,66,"cxz","lisi","小麦",66]
li.insert(3,99)
print(li)

B.计算元素出现的次数 count

li = [11,22,66,"cxz","lisi","小麦",66]
v = li.count(66)
print(v)

C. index（获取元素的位置，左边优先）    、clear   （清空列表 ）  、  copy（拷贝） 

F.pop删除某个值，并且获取删除的值 （没有指定则默认最后一个）

   remove删除列表的值（左边优先）

li = [11,22,66,"cxz","lisi","小麦",66]
v = li.pop(2)
print(li)
print(v)

li = [11,22,66,"cxz","lisi","小麦",66]
li.remove(66)
print(li)

G.reverse （ 将列表元素反转 ）       sort （列表排序）

li = [11,22,66,"cxz","lisi","小麦",66]
li.reverse()
print(li)

li = [11,22,66,55,42,9]
li.sort() 或者（revers = Ture）
print(li)

（4）元组　　  tuple

a.元组就是对列表的二次加工，元素的不可被修改、增加、删除

b.可以通过索引和切片去获取值，可以for循环，可迭代对象

v= tu[1:4]
v= tu[3]

c.元组是可以和字符串、列表相互转换的

d.元组的元素（列表）是可以修改的（不可修改的是元组一级元素不可修改）

元组格式：tu = (1,3,"zhansan","李四","wangwu","小米",66,99)

元组功能：1.count （元素的次数 value）          2.index（获取元素位置 value）

（5）字典　　  dict

字典格式：info ={key1：value1，key2：value2，key3：value3，。。。}

a.布尔值、列表、字典是不能作为字典中的key，value可以是任何值

b.字典是没序的

c.获取通过索引获取、删除

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
v=info["K3"][0]
print(v)

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
del info["K3"][1]
print(info)

d.for循环获取key，value

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
for item in info:
    print(item)
只获取key

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
for item in info.values():
    print(item)
只获取value

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
for k,v in info.items():
    print(k,v)
获取 key和value

f.字典的功能：（常见重要：keys 、values 、items 、get 、update）

A.fromkeys (根据序列，创建字典并指定统一值)

v = dict.fromkeys(["k1",123,"张三"],123)
print(v)

B.get（根据key获取值，key不存在时，可以指定默认值）

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
v=info.get("k2","不存在则返回这个值")
print(v)

C.setdefault（设置值，已存在，获取当前的值，不存在，设置获取当前对应的值）

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
v = info.setdefault('k1','123')
v1 = info.setdefault("k4", '123')
print(info,v)
print(info,v1)

D.update（修改更新）

info = {"k1":5,7:True,(44,55):"v1","k2":"v2","K3":["jkh",789]}
info.update(k1=123,k2=456)
print(info)

（6）布尔值　  bool  （false  、True ）

9.集合  （1.不同的元素组成    2.无序     3.集合中元素必须是不可变类型）

（1）集合的定义：

s={1,3,4,4,5,6,7,"zhanasan","李四"}
或者s = set('134567')
或者s = set([1,3,4,4,5,6,7,"zhanasan","李四"])

（2）集合的增加：add

s = set([1,3,4,4,5,6,7,"zhanasan","李四"])
s.add("xiaoming")
print(s)

 （3）集合的删除：pop （随机删除）  remove（指定删除）  discard （指定删除，没有不会报错）

s = set([1,3,4,4,5,6,7,"zhanasan","李四"])
s.pop()
print(s)

s = set([1,3,4,4,5,6,7,"zhanasan","李四"])
s.remove(5)
print(s)

s = set([1,3,4,4,5,6,7,"zhanasan","李四"])
s.discard(8)
print(s)

（4）集合的交集： intersection 、&

s = {1,3,4,"zhangsan","李四","小麦","wangwu",22}
c = {3,"zhangsan","李四","小天","liming",66}
print(s & c)
print(s.intersection(c))

（5）集合的并集： union 、 |

s = {1,3,4,"zhangsan","李四","小麦","wangwu",22}
c = {3,"zhangsan","李四","小天","liming",66}
print(s|c)
print(s.union(c))

 （6）集合的差集：  difference  、-

s = {1,3,4,"zhangsan","李四","小麦","wangwu",22}
c = {3,"zhangsan","李四","小天","liming",66}
print(s-c)
print(s.difference(c))

 10.函数  def

函数的特性：1.代码重用  2.保持一致性，易维护   3.可扩展性

函数的格式：

def  函数名（可有可无变量）：

　　函数的代码

　　return 函数值

注意：函数代码中遇到return，即结束掉函数

调用函数格式：

变量名 = 函数名 （可有可无变量）

（1）接收函数变量：*args（列表类型）  、 **kwargs（字典类型）

（2）局部变量和全局变量：

a.子程序优先获取局部变量，没有再获取全部变量

b.在子程序中要对全局变量重新赋值需要声明全局变量： global  +变量名

c.指定上一级变量： nonlocal

（3）函数风湿理论：函数即变量（前向引用：调用函数一定在定义函数后面）

（4）函数的递归：函数在内部调用自身本身，即函数就是递归函数

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    res = calc(int(n/2))
    return res
calc(10)

（5）作用域：指定变量的可用范围

注意：在函数嵌套时，不能直接调用嵌套的函数

（6）匿名函数格式：lambda x  : x+1（后面可加传参的列表名）

name = "alex"
fance = lambda x:x+"_sb"
print(fance(name))

（7）判断高阶函数：1.函数接受一个函数    2.返回值包含函数

（8）尾调用优化：在函数的最后一步调用另一个函数

（9）内置函数：

map函数格式：map（函数方法，列表）————》遍历列表执行函数的方法

num_1 = [1,6,8,10,9,14]
res = map(lambda x:x+1,num_1)
print(list(res))

 filter函数的格式：filter（函数，列表）————》遍历列表，函数为真则保存

people_name =["alex_sb","zhansan_sb","lisi_sb","xiaomai"]
res=filter(lambda n:not n.endswith('_sb'),people_name )
print(list(people_name))

reduce函数格式：reduce（函数，列表，指定（选写））————》遍历列表执行函数累积一起

from functools import reduce
number = [1,3,5,100]
print(reduce(lambda x,y:x*y,number))

 注意：

map：处理序列中的每个元素，得到结果是一个列表

filter：遍历序列中每个元素，判断每个元素得到布尔值，为真则保存下来（筛选功能）

reduce：处理一个序列，然后把序列进行合并操作

abs（取绝对值） 、all（判断所有元素布尔值，只要一个为假，都为假）、any（判断所有元素布尔值，只要一个为真，都为真）、bin（把十进制转成二进制）、bool（判断布尔值）、bytes（把字符串转成二进制）、char和ord（相互转成）、divmod（翻页）、hex（十六进制）、max、min（取最大最小值）、zip（拉列）、round（四出五入）、sum（计算总和）

11.文件处理

（1）open  打开文件： open（文件名，文件的权限，读取文件格式）

f = open('file_test','r',encoding='utf8')
date = f.read()
print(date)

 文件的功能：r（读取）　　　　w（编写）　　　　a（追加到后面）