python基本语法2

第四章

4.1函数介绍 

len函数 

功能：得到字符串的长度

语法：len(字符串变量/字符串)，函数返回字符串的长度

头文件：python内置函数

name="牛帅涵"

length1=len(name)    #返回字符串长度3


#功能同上
length2=len("牛帅涵")

自定义my_len函数

功能：和len内置函数功能一致

#自定义my_len函数
def my_len(str):
    count=0
    for i in str
        count++
    return count

name="牛帅涵"
length=my_len(name)    #返回3

4.2函数的定义 

语法：

def 函数名（形参1，形参2，......）：

[][][][]函数体

[][][][]return 返回值

注意事项：

• 参数如不需要，可以省略(后续章节讲解)
• 返回值如不需要，可以省略(后续章节讲解)
• 函数必须先定义后使用 

4.3函数的参数 

函数定义中，提供的参数，称之为形式参数(形参) ，表示函数声明将要使用的参数
●参数之间使用逗号进行分隔
函数调用中，提供的参数，称之为实际参数(实参)，表示函数执行时真正使用的参数值
●传入的时候，按照顺序传入数据，使用逗号分隔

4.4函数的返回值 

函数体在遇到return后就结束了，所以写在return后的代码不会执行。 

None类型

如果函数没有使用return语句返回数据，那么函数有返回值吗?----------实际上是有的。
Python中有一个特殊的字面量: None，其类型是: <class 'NoneType'>
无返回值的函数，实际上就是返回了: None这个字面量

None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。也就是返回了空的意思。

#定义hello函数，无return语句
def hello():
    print("helloworld")

#定义变量result接受hello函数返回值
result=hello()

print(result)          #结果None
print(type(result))    #结果<class 'NoneType'>

None可以主动使用return返回，效果等同于不写return语句:

def hello():
    print("helloworld")
    return None

在if判断语句中，None相当于False

def check(age):
    if age>18:
        return "SUCESS"
    else:
        return None

result=check(16)

if not result:
    print("你还没成年")

用于声明无内容的变量：
定义变量，但暂时不需要变量有具体值，可以用None来代替

#暂不赋予变量具体值
name=None

4.5函数说明文档 

我们可以给函数添加说明文档，辅助理解函数的作用。

语法：

def 函数名(形参x，形参y):
   """
   函数说明
   :param x:形参x的说明
   :param y:形参y的说明
   :return:返回值的说明
   """
   函数体
   return 返回值

通过多行注释的形式，对函数进行说明解释 

注意：说明文档应写在函数体之前 

在PyCharm编写代码时：可以通过鼠标悬停，查看调用函数的说明文档；可以在函数体前输入三个引号，回车自动形成如上的规范语法

4.6变量的作用域 

变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用)
主要分为两类：局部变量和全局变量

局部变量：定义在函数体内部的变量，即只在函数体内部生效

全局变量：定义在函数体外部的变量，在函数体内、外都能生效

global关键字

num=100

def test():
    num=200         #定义一个局部变量num，他和全局变量num没有任何关系
    print(num)      #输出200

print(num)          #输出100

那么怎么在函数内部，修改全局变量的数值呢？

使用global关键字可以在函数内部声明变量为全局变量，如下所示：

num=100

def test():
    global num=200;   #通过global关键字，说明num是全局变量，他和第一行代码num是同一个
    print(num)        #输出200

print(num)            #输出200

第五章

5.1数据容器入门

Python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如:

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

可以分为5类，分别是：列表(list) 、元组(tuple) 、字符串(str)、集合(set) 、字典( dict)

5.2数据容器: list (列表)

列表的定义格式

基本语法：

#字面量
[元素1，元素2，...]

#定义变量
变量名称=[元素1，元素2，...]

#定义空列表
变量名称=[]
变量名称=list()

• 以[ ]作为标识
• 列表内每一个元素之间用逗号隔开

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

my_list=["niushuaihan",[1999,2,13],True]

print(my_list)           #输出["niushuaihan",[1999,2,13],True]
print(type(my_list))     #输出<class 'list'>

list (列表)的遍历

列表中的每一个元素，都有其位置（下标索引），从前向后的方向：从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。
或者，可以反向索引，也就是从后向前：从-1开始，依次递减(-1、 -2、-3...... )

my_list=["niushuaihan",[1999,2,13],True]

print(my_list[0])       #输出niushuaihan
print(my_list[1][0])    #输出1999
print(my_list[-1])      #输出True

既然数据容器可以存储多个元素，那么就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为：遍历或迭代。

while循环遍历list列表

my_list=["niushuaihan",1,True]

index=0
while index<len(my_list):
    print(my_list[index])
    index++

for循环遍历list列表

my_list=["niushuaihan",1,True]

"""
    for循环语法格式：
        for 临时变量 in 数据容器
            对临时变量进行处理

    解释：
        表示从容器内，依次取出元素并赋值到临时变量上。在每一次的循环中，我们可以对临时变量(元素) 
        进行处理。
        也就是说，这个临时变量就是数据容器的一个个元素（注意不要把临时变量当成下标索引）

"""
for element in my_list:
    print(element)

#错误示范：把临时变量当成下标索引
"""
for i in my_list
    print(my_list[i])
"""

 列表的常用操作

在Python中，如果将函数定义为class (类)的成员，那么函数会称之为：方法

查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表对象.index(元素)，返回值：下标索引
index就是列表对象(变量)内置的方法(函数)

修改特定位置(索引)的元素值

语法：列表对象[下标]=值
可以使用如上语法，直接对指定下标(正向、反向下标均可)的值进行重新赋值（修改）

插入元素

语法：列表对象.insert(下标,元素)，在指定的下标位置，插入指定的元素

追加元素

语法：列表对象.append(元素)，将指定元素，追加到列表的尾部

追加元素方式2

语法：列表对象.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

删除元素

语法1: del 列表对象[下标]
语法2：列表对象.pop(下标)；返回值是被删除的元素

删除某元素在列表中的第一个匹配项

语法：列表对象.remove(元素)

清空列表内容

语法：列表对象.clear()

统计某元素在列表内的数量

语法：列表对象.count(元素)，返回值是指定元素在列表中的个数

统计列表中总共有多少个元素

语法：len(列表对象)；返回值：列表元素总个数

列表的特点总结

经过上述对列表的学习，可以总结出列表有如下特点:

• 可以容纳多个元素(上限为2**63-1 ，即9223372036854775807个，可以认为是无穷多个)
• 可以容纳不同类型的元素(混装)
• 数据是有序存储的 (有下标序号)
• 允许重复数据存在
• 可以修改(增加或删除元素等)

5.3数据容器: tuple (元组)

元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：元组一旦定义完成，就不可修改。

元组的定义格式

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

#定义元组字面量
(元素1，元素2，...)

#定义元组变量
变量名称=(元素1，元素2，...)

#定义空元组
变量名称=()
变量名称=tuple()

注意事项：

• 元组内只有一个数据时，这个数据后面要添加逗号！！！

#定义三个元素的元组
t1=("niu",1,False)

#定义一个元素的元组
t2=(2,)                #注意，必须带有逗号，否则不是元组类型
print("t2的类型是："，type(t2),"t2的数值是：",t2)      
     #输出   t3的类型是：<class 'tuple'>t3的数值是：（2）

#若不添加逗号，类型是字符串型
t3=(3)
print("t3的类型是："，type(t3),"t3的数值是：",t3)      
     #输出   t3的类型是：<class 'str'>t3的数值是：3

• 元组支持嵌套

#嵌套元组
t1=("niu",(1999，2，13),True)

t2=("hou",[2019.6,2])

•  元组支持下标索引的方式访问元素，方法和list相同

虽然元组定义的时候使用小括号( )，但是访问元素的时候还是用中括号[ ]

t1=(1,2,3)

#访问元素0，正确示范
print(t1[0])

#访问元素1，错误示范
#print(t1(1))

• 不可以修改元组的内容，否则会直接报错

t1=("niu"，1，False)

#尝试修改元组中的元素，会直接报错
t1[1]=2          #报错

• 可以修改元组内的list的内容(修改元素、增加、删除、反转等)

t1=("hou",[2020,6,2])

t1[1][0]=2019     #修改成功

•  允许重复数据存在

元组的基本操作

方法	功能	使用
index(元素)	查找某个元素下标，如果元素存在返回对应的下标，否则报错	使用方法同list
count(元素)	统计某个元素在当前元组出现的次数	使用方法同list

len函数：统计元组内的元素个数，使用方法同list 

5.4数据容器: str (字符串)

尽管字符串看起来并不像列表、元组那样，但一看就是存放了许多数据的容器。不可否认的是，字符串同样也是数据容器的一员。
字符串是字符的容器，一个字符串可以存放任意数量的字符。

字符串的定义格式

定义字符串使用单引号/双引号/三引号，不需要隔开各个数据，数据可以是字母/数字/符号

#定义字符串字面量
"元素1元素2..."

#定义元组变量
变量名称="元素1元素2..."

#定义空元组
变量名称=""
变量名称=str()

注意事项

• 支持下标索引的方式访问元素，方法和list相同

s1="niushuaihan"

#访问元素
print(s1[1])

•  不可以修改字符串的内容，否则会直接报错
• index(子字符串)方法

查找子字符串在原有字符串中的起始下标

s="niu shuai han"

num=s.index("shu")
print(num)            #输出3

•  字符串的替换

语法：字符串对象.replace(字符串1,字符串2)；返回值：新的替换后的字符串
功能：将字符串内，全部能和字符串1匹配的子字符串,替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串

s="abcabc"

s1=s.replace("a","h")
print(s)               #输出abcabc
print(s1)              #输出hbchbc

• 字符串的分割 

语法：字符串对象.split(分隔符字符串)；返回值：列表对象
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象

s="niu shuai han"

l=s.split(" ")          #利用空格进行分割
print(l)                #输出["niu","shuai","han"]
print(s)                #输出niu shuai han

• 字符串的规整操作( 去前后空格/回车换行符) 

语法：字符串对象.strip()；返回值：新的字符串

注意：字符串本身不变，而是得到了一个新的字符串

• 字符串的规整操作(去前后指定字符串)

语法：字符串对象. strip(字符串)；返回值：新的字符串
注意：字符串本身不变，而是得到了一个新的字符串

s="12niu shuai han321"

s1=s.split("123")
print(s)                 #输出12niu shuai han321
print(s1)                #输出niu shuai han

"""
    split("123")的意思，并不是说把字符串前后的子字符串"123"给去除
    而是将"123"中的每一个字符都看作独立的，只要字符串前后的某个字符属于"123"
    就会把它去除
"""

•  统计字符串中某子字符串的出现次数

语法：字符串对象.count(子字符串)；返回值：整数

s="ab sd abba"

num=s.count("ab")
print(num)         #返回2

• 统计字符串的长度

使用len函数，方法同list

5.5数据容器的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串，均可以视为序列。

切片：从一个序列中，取出一个子序列
语法：序列[起始下标：结束下标：步长]；返回值：一个新的相同数据类型的序列
含义：表示从序列中，从指定位置开始，依次取出元素，到指定位置结束（不包含结束下标的元素），得到一个新序列:

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标表示在何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔，可以留空，留空视作步长为1；步长1表示，一个个取元素；步长2表示，每次跳过一个元素取；步长N表示，每次跳过N-1个元素取；步长为负数表示反向取(注意，起始下标和结束下标也要反向标记)

注意：切片操作不会影响序列本身

#对列表list切片
my_list=[0,1,2,3,4,5]
l=my_list[1:5]
print(l)                            #输出[1，2，3，4]
print(type(my_list))                #<class 'list'>

l1=my_list[::-1]
print(l1)                            #[5，4，3，2，1，0]

l2=my_list[5:3:-1]
print(l2)                            #[5，4]

#对元组tuple切片
my_tuple=(0,1,2,3,4,5,6)
t=my_tuple[:]
print(t)                            #(0,1,2,3,4,5,6)
print(type(t))                      #<class 'tuple'>

#对字符串str切片
my_str="012345678"
s=my_str[::2]
print(s)                            #02468
print(type(s))                      #<class 'str'>

 案例：取出字符串"万过薪月必，懈不持坚需，nohtyP好学"（学好Python，需坚持不懈，必月薪过万)中”坚持不懈“

s="万过薪月必，懈不持坚需，nohtyP好学"

#
s1=s[9:5:-1]

#倒序字符串，切片取出
s2=s[::-1][10:14]

#切片取出，然后倒序
s3=s[6:10][::-1]

#split分隔"，"  replace替换"需”为空，倒序宇符串
s4=s.split(",")[1].replace("需","")[::-1]

5.6数据容器: set(集合)

集合的定义

基本语法：

#定义集合字面量
{元素1，元素2，...}

#定义集合变量
变量名称={元素1，元素2，...}

#定义空集合
#变量名称={}            #这种方法不支持，因为需要和定义空字典相区分
变量名称=set()

• 集合是无序的，所以集合不支持下标索引访问
• 集合可以容纳多个数据，但不允许数据重复
• 集合可以容纳不同类型的数据
• 集合和列表一样，是允许修改的

 集合的基本操作

• 添加新元素

语法：集合对象.add(元素)，将指定元素，添加到集合内

结果：集合本身被修改，添加了新元素

my_set={1，2}

my_set.add(3)
my_set.add(2)
print(my_set)         #{1,2,3}

• 移除元素

语法：集合对象.remove(元素)，将指定元素，从集合内移除

结果：集合本身被修改，移除了元素 

• 从集合中随机取出一个元素

语法：集合对象.pop()；返回值：取出的元素；从集合中随机取出一个元素

结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

• 清空集合

 语法：集合对象.clear()，清空集合
结果：集合本身被清空

• 取出两个集合的差集

语法：集合对象1.difference(集命对象2)；返回值：新的集合对象

功能: 取出集合1和集合2的差集 (集合1有而集合2没有的)

结果：得到一个新集合，集合1和集合2不变

• 消除两个集合的差集

语法：集合对象1.difference_update(集合对象2)

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

结果： 集合1被修改，集合2不变

• 合并两个集合

语法：集合对象1.union(集合对象2)；返回值：新集合对象

功能：将集合1和集合2组合成新集合

结果：得到新集合，集合1和集合2不变

• 统计集合中元素总量

使用len函数，使用方法同list

my_set={1,2,3,1}

num=len(my_set)
print(num)           #3

•  集合的遍历

只能通过for循环遍历集合

my_set={1,2,3,4}

for element in my_set:
    print(element)

5.7数据容器: dict(字典、 映射)

字典的定义

字典的定义：同样使用{ }，不过存储的元素是一个个的键值对，语法如下：

#定义字典字面量
{key:value,key:value,...}

#定义字典变量
变量名称={key:value,key:value,...}

#定义空字典
变量名称={}
变量名称=dict()

• 字典同集合一样，不可以使用下标索引；但是字典可以通过Key值来取得对应的Value，使用方法：Value=字典对象[Key]

my_dict={"年":2019,"月":6,"日":2}

print(my_dict["月"])              #6

•  Key值不能重复，重复添加等同于覆盖原有数据
• 字典的Key和Value可以是任意数据类型(Key不可为字典）。那么就表明，字典是可以嵌套的

姓名\出生日期	年	月	日
老牛	1999	2	13
小侯	2000	5	10

my_dict={
            "老牛":{              #key:{key:value,... }
                "年":1999，         #key：value
                "月":2，
                "日":13
               },
            "小侯":{
                "年":2000，
                "月":5，
                "日":10
               }
         }

print(my_dict["老牛"])            #{"年":1999，"月":2，"日":13}
print(my_dict["小侯"]["年"])       #2000

 字典的常用操作

• 新增元素

语法：字典对象[Key]=Value，结果:字典被修改，新增了元素

注意：key要是不存在的话，就等同于新增元素；key要是存在，就等同于更新元素

• 更新元素

语法：字典对象[Key]= Value，结果:字典被修改，元素被更新

注意: 字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

• 删除元素

语法：字典对象.pop(Key)；返回值：key对应的value

结果: 获得指定Key的Value，同时字典被修改，指定Key的数据被删除

• 清空字典

语法：字典对象.clear()，结果:字典被修改，元素被清空

• 获取全部的key

语法：字典对象.keys()；返回值：由全部key组成的list

结果: 得到字典中的全部Key

• 遍历字典

my_dict={"年":2019,"月":6,"日":2}

keys=my_dict.keys()

#方式1:通过获取到全部的key来完成遍历
for key in keys:
    print(key," : ",my_dict[key])

#方式2:直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(key," : ",my_dict[key])

• 统计字典中全部元素的总数

 使用len函数，方法同list。

5.8数据容器的通用操作

• 函数：len(容器) ；返回值：统计容器的元素个数
• 函数：max(容器) ；返回值：统计容器的最大元素（对于字典来说，只比较Key）
• 函数：min(容器)； 返回值：统计容器的最小元素（对于字典来说，只比较Key）
• 函数：list(容器)；返回值：将给定容器转换为列表（字符串容器转列表：把每个字符转化成列表的元素；字典容器转列表：把每个key转化成列表元素）

my_str="abcd"
my_dict={"年":1999,"月":2,"日":13}

print(list(my_str))       #输出：['a','b','c','d']
print(list(my_dict))      #输出：["年","月","日"]

• 函数：tuple(容器)；返回值：将给定容器转换为元组(同上)
• 函数：set(容器)；返回值：将给定容器转换为集合(同上)
• 函数：str(容器)；返回值：将给定容器转换为字符串
• 函数：sorted(容器，[reverse：True])；返回值：有序的列表；功能：给指定容器排序；（reverse默认是false，从小到大排序）

my_tuple=(2,3,1,5)

my_list=sorted(my_tuple,reverse=True)
print(my_list)         #输出[5，3，2，1]