python基础语法学习速通笔记（有C语言基础版）

第一章基础语法知识

一，变量

（1）变量名可以="中文字符"，直接输出变量名

姓名="小袁"
print（姓名）
//小袁

（2）变量类型管理严格

        1.用type（）检测变量类型

        2.用int（）str（）...等转换类型

num="class1"
print(type(num))
//<class 'str'>

        3.特殊少用有：

                 chr（x）整数转为ascall表的字符

                 ord（x）字符转为ascall表的数字

二，数据类型

（1）引号运用

        1.单双引号：只能在一行输出

        2.三引号：可以分段

target='''摆烂
顺便有钱'''
print(target)
//摆烂
  顺便有钱

三，输入输出

（1）input函数输入

        1.input中输入的任何都为‘字符串’形式

（2）print函数输出

        1.print（）函数默认换行，如果需要不换行可以适用end=''

print（"我"）
print（"是"）
print（"小"，end=''）
print（"袁"）
//我
  是
  小袁

        2.多个输出可以用‘+’相加

        3.一行输出多个

数字用空格隔开：
a,b=map(int,input().split())
字符串用空格隔开：
a,b=map(str,input().split())

        4.sep()函数：控制输出数中的分隔符

#输出序列ab的长度用“，”分隔
print(len(lsa),len(lsb),sep=',')

        5.使用%进行格式化输出

        %b:二进制

        %o:八进制

        %d:十进制

        %x:十六进制

        %e:科学计数法

        %g:低于6位数字为科学计数法

print('%.3e'%2.22)#取3位小数使用科学计数法
//2.220e+00
print('%.7g'%2222.2222)#取7位有效数字
//2222.222
print('%.2g'%2222.2222)#取2位有效数字转为科学计数法
//2.2e+03

（3）格式化字符串输出

        1.f-字符串:print(f '{******}')

        2.format()函数：编号或标齐(<默认左对齐、>右对齐、^中间对齐、=小数点后补齐

print('{}{}'.format('hi','world')#不带编号
//hi world
print('{0}{1}'.format('hi','world')#带编号
//hi world
print('{0}{1}{0}'.format('hi','world')#打乱顺序
//hi world hi
print('{a}{b}{a}'.format(b='hi',a='world')#带关键字
//world hi world

print('{:10s}and{:>10s}'.format('你','好'))   #左对齐10位，右对齐10位
//你         and         好
print('{:^10s}and{:^10s}'.format('你','好'))      #中间10位对齐
//    你     and    好     

四，运算符和表达式

（1）补充运算符

        **幂 10**2=100

        //取整 9//2=2

第二章程序控制结构

一，选择语句

（1）if语句

        1.简单的if语句

        2.if...else语句

        3.if...elif...else语句    #elif相当于else if（）

二，循环语句

（1）while语句

        while（表达式）：

                语句块

（2）for循环语句

        for 变量 in 对象：

                语句块

sum=0
for n in range(1,100):    #生成1-100的整数不包括100
    sum+=n
print("1到99的整数和:"，sum)

（3）pass语句：占位使用

【例题】输出1-10偶数（pass占位不是偶数时）

for i in range（1,10）：
    if i%2==0：
        print（i，end=''）
    else:
        pass

第四章序列

一，列表

（1）列表的创建与删除

        1.创建空列表:  list=[]

        2.创建数值列表:  list=list(range(1,6))

        3.删除列表: 使用del命令  #del list

（2）访问列表元素

        1.索引可以正向（0~n）也可以逆向（-n~-1）

 （3）添加元素

        1.append():在末尾追加元素

book=["hi","world"]
print(len(book))
// 2
book.append("hello")
book.append("ear")
print(len(book))
// 4

        2.insert():将元素添加于指定位置

list=[1,2,3,4,5]
list.insert(2,9)   #向第2个元素后添加一个新元素9
print(list)
//list[1,2,9,3,4,5]

        3.extend():将另一个对象的元素添加至该对象的尾部       

list=[1,1,2]
list.extend([3,4])
print(list)
//[1,1,2,3,4]

        4.“+”运算符:将元素加入列表

list=[1,2,3]
list+=[4]
print(list)
//[1,2,3,4]

        5.“*”运算符:列表与整数相乘，生成新列表

list=[1,2,3]
list*=3
print(list)
//[1,2,3,1,2,3,1,2,3]

        6.sample函数：sample（a，n），从a中随机取出n个元素组成列表

        7.math库的factorial：阶乘

import math
def main(num):
    return math.factorial(num)
print(main(5))

（4）删除元素

        1.del：删除指定位置元素

list=['a','b','c','d']
del list[0]
print(list)
//['b','c','d']

        2.pop():删除末尾元素

list=['a','b','c','d']
list.pop()
print(list)
//['a','b','c']

        3.remove():删除首要出现的指定元素

list=[1,2,3,4,5,6,7]
list.remove(4)
print(list)
//[1,2,3,5,6,7]

（5）修改元素

【例】1.直接代表式替换2.replace函数

book=["hi","world","oo"]
book[2]="ear"
print(book)
//['hi','world','ear']
book="hi world oo"
books=book.replace('hi','hello')
print(books)

二，列表统计

(1)获取指定元素出现次数 count

book=["hi","hi","hi","hello"]
num=book.count("hi")
print(num)
//3
print("MacBook Pro".count("o", 5,8))  #从第5个字符到第8个字符结束
//2

(2)获取指定元素首次出现的下标index

book=["hi","hello","oh","no"]
num=book.index("hi")
print(num)
// 0

(3)统计列表元素和sum

score=[1,2,3,4,5]
total=sum(score)
print("总分是:",total)
// 15
totalplus=sum(score,10)
print("加上10的总分是:%d"%totalplus)
// 25

三，列表排序

（1）使用sort()方排序：Ture降序，False升序，默认升序

list=[1,2,3,4,5,6,7,8,9,10]
import random  #头文件提供random
random.shuffle(list)  #打乱排序
print(list)
//[4,9,10,6,2,8,1,3,7,5]

list.sort()  #升序
print(list)
//[1,2,3,4,5,6,7,8,9,10]

list.sort(reverse=True)  #降序
print(list)
//[10,9,8,7,6,5,4,3,2,1]

book=["hi","Hello","Oh","no"]
book.sort()  #区分大小写排序，先排大写
print(book)
//['Hello', 'Oh', 'hi', 'no']

book.sort(key=str.lower)  #不区分大小写排序
//['Hello', 'hi', 'no', 'Oh']

(2)内置sorted排序:生成新列表，原列表顺序不变

score=[2,3,5,4,1]
score1=sorted(score)  #升序
//[1,2,3,4,5]

score2=sorted(score,reverse=True)  #降序
//[5,4,3,2,1]

四，成员资格判断

（1）用in判断，Ture为存在False为不存在

（2）用not in判断，Ture为不存在False为存在

（3）写法为:"hi" in book与"hi" not in book

五，切片操作

（1）list [start : end : step]  #start如未指定为起点默认0 ，end如未指定默认结尾长度，step为步长默认1，如果省略步长则可以省略最后一个冒号

list=[1,2,3,4,5,6,7,8,9,10]
list[1:3]  #1开始3结束（不包括3）
//[2,3]
list[:3]   #1开始3结束（不包括3）
//[1,2,3]
list[1:]   #1开始取到末尾
//[2,3,4,5,6,7,8,9,10]
list[::-1]   #从尾取到头
//[10,9,8,7,6,5,4,3,2,1]
list[100:]   #从100开始取，不存在
//[]
list[-2]   #取出倒数第二个
//9

(2)可结合del命令与切片操作删除列表中部分元素

list=[1,2,3,4]
del list [:1]
print(list)
//[3,4]

（3）split函数

        1.str.split('分隔符', 分裂次数). #将一个字符串分割为多个,如需保留分隔符则写split([])

str="abc \ndef \nghi"
print(str.split( ))       # 以空格为分隔符，包含 \n
print(str.split(' ', 1 )) # 以空格为分隔符，分隔成两个
//['abc', 'def', 'ghi']
//['abc', '\ndef \nghi']

六，列表推导式

（1）语法格式

        1. [表达式 for 代替的变量 in被代替的对象 [if条件表达式] ]

        （if条件表达式可省略，类似C语言中的for循环，第一个表达式为循环后执行的过程，代替的变量一个个取出被代替对象的数）

        2.可以有多重循环[表达式 for 代替的变量 in被代替的对象 for 代替的变量 in被代替的对象 ]

七，二维列表

（1）for循环实现赋值

list=[]   #创建空列表
for i in range(3):
    list.append([])   #空列表中添加空列表
    for j in range(4):
        list[i].append(j)   #内层添加元素
print(list)
//[0,1,2,3],[0,1,2,3],[0,1,2,3]

（2）列表推理式创建

list=[[j for j in range(4)]for i in range(3)]
print(list)
//[0,1,2,3],[0,1,2,3],[0,1,2,3]

（3）访问时用下标定位

list=[['hi','hello','oh','no'],['shit','fuck','god','dawn']]
print(list[1][2])
// god

八，元组

（1）创建元组

        1.与创建列表类似，但是列表为方括号，元组为圆括号，用逗号隔开

        2.tuple=()

（2）访问元组

        1.使用下标索引访问：tuple[0]、tuple[1]

        2.切片获取：tuple[2:5]

        3.for循环：for element in tuple

                                print(element)

（3）修改元组

        1.元组中单个元素不允许改变，但可以重新赋值整个元组

        2.元组中元素可以连接组合：tuple3=tuple1+tuple2

（4）删除元组

        1.元组不可删除单个、部分的元素，但能用del命令删除整个元组对象：del tuple

（5）元组推导式

        1.语法：（表达式 for 变化变量 in 变量 [if 条件表达式]）

        2.用推导式得出不为元组，是生成器对象

tuple=(x for x in range(10))
print(tuple)
//<generator object <genexpr> at 0x00000201B03B17D8>

        3.获得元组可以使用语法：tuple1=（）  tuple（tuple1）

        4.获得元组还可以使用__next__()方式遍历生成器对象获得元素(os.两个下划线）

tuple1=(x for x in range(1,10))
print(tuple1.__next__())   #获取单个元素
tuple1=tuple(tuple1)    #获得单个单个的元素
print(tuple1)        #一起输出
//1
(2, 3, 4, 5, 6, 7, 8, 9)

（6）元组的常用内置函数

        1.常用内置函数

                 len（tuple）：计算元组中元素个数

                 max（tuple）：返回元组最大值

                 min（tuple） ：返回元组最小值

                 tuple（seq） ：将列表转为元组

（7）序列封包和序列解包

        1.序列封包:可以直接赋值多个变量

tuple=1,2,3
print(tuple)
print(type(tuple))
//(1, 2, 3)
<class 'tuple'>

        2.序列封包:可以将序列直接赋值多个变量

tuple1=tuple(range(1,10,2))
print(tuple1)
//(1, 3, 5, 7, 9)

a,b,c,d,e=tuple1
print(a,b,c,d,e)
//1 3 5 7 9

        3.序列解包:使用range函数

a,b,c=range(3)
print(a,b,c)
//0,1,2

九，字典

（1）字典的含义特性

        1.字典相当于保存两组数据，一组为关键数据，称为“键（key）”，另一组数据可以通过键来访问被称为“值（value）”

        2.字典的特性：（1）通过键访问值，所以键是唯一的且不可变的

                                 （2）不支持索引和切片

                                 （3）字典是无序对象集合用键存取，列表是有序对象集合用偏移量存取

                                 （4）字典可变，可以任意嵌套

（2）字典的创建与删除

        1.创建字典：用{}标识，键值用：隔开，键值对用逗号隔开，或dict()内置函数创建，用zip()打包

keys=["语文","数学","英语"]
values=[67,91,78]
dict1=dict(zip(keys,values))  #zip()函数将对应元素打包成一个个元组然后返回元组组成列表
print(dict1)
//{'语文': 67, '数学': 91, '英语': 78}

        2.删除字典：用函数clear()清空所有元素，变为空字典：【如】garde.clear()

（3）访问字典

        1.键值对操作：

                       （1）通过键访问值

                       （2）通过键增加删除修改键值对

                       （3）通过键判断键值对是否存在：若访问时不存在代码报错

        2.用get（）获取指定值：dict.get（key,可选项） #可选项当指定键不存在时返回默认值，如果省略则返回None       

garde={"语文"67:,"数学":91,"英语":78}
garde.get("计算机","不存在此课程")
//'不存在此课程'
garde.get("计算机")
//     #返回值为None 屏幕不可见

        3.使用items()获取键值对列表、keys()获得键列表、values()获取值列表

        items=grade.items()

        values=grade.values()

        keys=frade.keys()

        4.使用list()函数将key，values，iteams转换为列表:list(iteams) 结果带方括号

        5.for循环可以遍历items：for key,value(iteam) in grade.items():

        6.pop()函数获取指定键对应的值，并删除这个键值对

garde={"语文"67:,"数学":91,"英语":78}
print(grade.pop("英语"))
//78
print(grade)
//{'语文':67,'数学':91}

（4）添加、修改、删除字典元素

        1.添加：dict[key]=value或使用update（）函数，类似升级覆盖

        2.修改：与添加类似直接修改

        3.删除：del命令删除键

（5）字典推导式

         1.语法：{表达式:表达式 for 变化变量 in 变量 [if 条件表达式]}

十、集合

（1）集合的创建与删除

        1.用{}创建：day={'Mon','Feb'}，创造空集合是set（）不可以是set{}因为{}是空字典

        2.如果有重复元素则自动保留一个

        3.集合也支持推导式

        4.使用set()函数将列表、元组、range对象等等转换为集合：setname=set(转换的模板)

           将字符串转换为字符集合 

        5.del删除集合 del numset

（2）集合元素的添加与删除

        1.add()添加字符串数字布尔类型的True或False：bookset.add("hi")

        2.pop(),remove()删除一个元素，clear清空元素

（3）集合的并集、交集、差集

        1.并集a | b ,交集a & b或a.intersection(b),差集a - b或a.difference(b)

a=set('abc')
b=set('cdef')
print(a|b)
//{'b', 'a', 'e', 'd', 'c', 'f'}
print(a&b)
//{'c'}
print(a-b)
//{'b', 'a'}

第五章 字符串

一、基本概念

（1）判断是否为字符串可以使用isinstance()函数

 （2）三引号多行输出每句后加‘；’，第一句后加入‘ \ ’可以美观省去输出第一行的换行

二、索引与切片

（1）索引：在python中不可以用索引改变字符串内容，只能使用字符串拼接方法

（2）切片：与列表类似

三、字符串的拼接

（1）加号连接

change="py"
way=change+"thon"
print(way)
//'python'

（2）%连接

change="py"
way="%sthon"%change
print(way)
//'python'

（3）join()：将指定字符串变为分隔符，连接元素

",".join(["hi","world","python"])
//'hi,world,python'

symbol = "-"
seq = ("a", "b", "c")
print symbol.join( seq )
//a-b-c

（4）filter():过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象；

#找出字符串中的数字
a = "".join(list(filter(str.isdigit, '123ab45')))
print(a)
//12345

四、原始字符串和格式化字符串

（1）原始字符串：

        1.在字符串前加入先导符"r"或"R"之后字符串的内容便不会被转义

        2.如果要保留一种引号则用另一种引号包含，如果保留两种则用三引号

（2）格式化字符串：

        1.{参数位置：格式化规则}

           [对齐方式][符号显示规则][#][0][填充宽度][千分位分隔符][.<小数精度>][显示类型]

        2.对齐方式中的‘=’：将填充文本放在正负号右边

a="{0:=+5}".format(10)
print(a)
//+  10

        3.符号显示规则：

                (1){}内数字前有-时如果()内数字为负才显示，如果{}内为+时正负都显示，如果

                    为空格的话表示()内数字为正显示空格，为负显示负号

"{0:< 5}{0:<-5}{0:<+5}{0:<5}".format(10)
//' 10  10   +10  10   '
"{0:<5}{0:<-5}{0:<+5}{0:< 5}".format(-10)
//'-10  -10  -10  -10  '

                (2){}内为#时如果以二进制显示数字则前导符为“0b”八进制为“0o”十六进制为“0x”，

                    #号后的0相当于吧填充字符改为0

print("{0:<#8b}{0:<#8o}{0:<#8d}{0:<#8x}{0:#8X}".format(10))
//0b1010  0o12    10      0xa          0XA

                (3)千分位分隔符：“ , ”和“ _ ”

"{0:10,}{0:10_}".format(1000000)
//' 1,000,000 1_000_000'

        4.strip函数去除左右字符（默认空格和换行符,除了中间）

a.strip()   #去除两边空格或字符
a.lstrip()   #去除左边空格或字符
a.rstrip()   #去除右边空格或字符

        5.capitalize()：将第一个字符变大写，其他变小写

str.capitalize()

        6.isnumeric()：判断字符串是否全为数字，是为Ture，否为False

        7.str.isdigit()：字符串中的所有字符都是数字返回Ture ，否则返回False

           str.isalpha()：字符串中的所有字符都是字母返回Ture ，否则返回False

           str.isalnum()：字符串中只有数字和字母，返回True，否则返回False

        8.center() 返回一个原字符串居中,用空格填充至长度 width 的新字符串。默认填充字符为空格

s.center(20,"*")
s.center(1,"*")

五、字符串的编码

（1）chr()函数将数字转为字符，ord()函数将字符转为数字

（2）一次性转换多个字符，为字节串，在字符串前加字符b

（3）字节串数据类型是bytes

（4）encode()函数将源字符串转为字节串自变量，decode()将字节转为对应字符

string="测试"
gbk=string.encode("gbk")
print(gbk)
//b'\xb2\xe2\xca\xd4'
print(gbk.decode("gbk"))
//'测试'

六、字符串常用操作

（1）eval()函数：表达式转换

（2）find()函数：查询

（3）split()函数：字符串分解

第六章 函数

一、普通函数

（1）基本定义及调用

        1.定义：def 函数名(参数列表):

        2.规则：(1)括号内可以定义参数列表，即便为0个也要有圆括号，函数形参不用声明类型

                      (2)函数第一行语句可以选择性的使用文档字符串存放函数说明，用help()查看

def like(language):
    '''打印喜欢的编程语言！'''
    print("我喜欢{}语言！".format(language))
    return
print(help(like))
//Help on function like in module __main__:
  like(language)
  打印喜欢的编程语言！

                      (3)使用return返回一个值给调用方，不适应则相当于返回None

（2）文档字符串

        1.规定：(1)第一行为对项目的的简要描述

                      (2)如果多行，第二行为空白行，目的是将摘要与其他描述直觉是分割开增加可读性

        2.可以用help()或者“函数名.__doc__”

def a(n):
    '''函数的简要描述

    其他描述'''
    return
print(help(a))
print("----------------------")
print(a.__doc__)
//
Help on function a in module __main__:

a(n)
    函数的简要描述
    
    其他描述

None
----------------------
函数的简要描述

    其他描述

（3）函数标注

        1.函数标注是关于用户自定义函数中使用参数类型的元数据信息，以字典形式存放于函数“__annotations__”属性中，不会影响函数其他部分

        2.函数返回值的标注方式：在形参列表和def语句结尾的冒号之间加上复合符号“->”和数据类型

        3.函数标注只是标注了参数或返回值的类型，但不限定类型

        4.函数定义和调用时，参数或返回值类型是可以改变的

def a(p1:str,p2:str="i like!")->str:
    s=p1+" "+p2
    print("函数表述:",a.__annotations__)
    print("传递的参数:",p1,p2)
    return s
print(a("python"))
//
函数表述: {'p1': <class 'str'>, 'p2': <class 'str'>, 'return': <class 'str'>}
传递的参数: python i like!
python i like!

（4）变量作用域

        1.内部函数可以用global定义全局变量

二、匿名函数：没有使用def而用lambda方式定义

（1）匿名函数名=lambda[arg1 [,arg2,····argn]]:expression   #arg*为参数列表，expression为表达式

（2）匿名函数更简洁，拥有自己的命名空间不可访问自己空间以外的参数，但只是一个表达式不是代码块，只能封装有限的逻辑

v=lambda a,b: b**2-a**2
x,y=4,5
print("{}*{}-{}*{}={}".format(y,y,x,x,v(x,y)))
//5*5-4*4=9

三、参数传递

（1）给函数传递不可变对象

        1.给函数内部改变赋值，内部形成一个新的a，不会影响外部，再次查看外部变量值不变

        2.str、int、tuple、float为不可变对象

（2）给函数传递可变对象

        1.给函数内部改变赋值，内外对象本身也会改变

        2.list、dict为可变对象

四、参数类型

（1）位置参数

        1.位置参数在函数调用时是必须得，并且顺序和数量都要与声明一致

        2.就是def a(p1,p2)括号内有两个值，调用时候a（2,3）也要有两个值

（2）关键字参数

        1.关键字参数可以随意摆放顺序但一定要跟在位置参数后面

def a(p1,kp1,kp2)
    print(p1,kp1,kp2)
    return
print(a("p1",kp2="kp2",kp1="kp1"))   #调用中kp1、kp2为关键字参数，p1为位置参数
//p1 kp1 kp2                         #函数调用中p1必须有而且与声明时一致

（3）默认参数

        1.参数使用了默认值，如果调用时没有传递参数则使用默认值

def member(name,id,grade="大一"): #默认值为大一
    print("姓名",name)
    print("学号",id)
    print("年级",grade)
    print("----------------------------")
    return
member("张三","0001")
member("李四","0002","大二")
//
姓名 张三
学号 0001
年级 大一
----------------------------
姓名 李四
学号 0002
年级 大二
----------------------------

（4）不定长参数

        1.希望函数参数个数不确定

        2.两种方法，第一种：*parameter和**parameter

           前者接受多个实参放于一个元组，后者接受键值对放于字典

def functionname([args,]*var_args_tuple):
    function_suite
    return [expression]
--------------------------------------
def functionname([args,]**var_args_dict):
    function_suite
    return [expression]

【例】

#对所有数字求和
def allsum(*a):
    sum=0
    for ele in a:
        sum+=ele
    return sum
print(allsum(1,2,3))
print(allsum(1,2,3,4,5))
-------------------------------
#列出使用者信息
def userinfo(**p):
    print(p)
    for k,v in p.items():
        print(k,":",v)
userinfo(name='bob',id='0001'sex='male')
userinfo(name='mike',id='0002'sex='male')

（5）特殊形式

        1.为确保可读性和运行效率，可以限制参数传递类型，在参数列表中添加“ / ”或“ * ”

        2.若未定义“ / ”或“ * ”则参数传递类型可以是位置参数或关键字参数

        3.如果使用“ / ”则符号前的形参仅限位置参数，调用时实参形参一一对应

        4.如果使用“ * ”则负号后形参仅限关键字参数，调用时实参形参位置随意

        5.在“ / ”和“ * ”中间的形参可以是位置参数也可以是关键字参数

（6）参数传递的序列解包

        1.包含多个位置参数的形参，用可变对象作为实参进行数据传递

        2.在实参前加一个星号（*），解释器开始对实参解包（字典键和形参不用一致）

def fuc(p1,p2,p3)
    print(p1,p2,p3)
    return
-----------------------
list1=["a1","a2","a3"]   #对列表解包(元组集合其他类型类似)
func(*list)
-----------------------
dict={'a':1,'b':2,'c':3}
func(*dict)   #对键解包
//a b c
func(*dict.values())   #对值解包
//1 2 3

·        3.在实参前加两个星号（**）针对字典值解包，字典的键和形参名称需保持一致

def fumc(p1,p2,p3):
    print(p1,p2,p3)
    return
p={'p1':1,'p2':2,'p3':3}
func(**p)
//1 2 3
-----------------
p={'a1':1,'a2':2,'a3':3}
//错误