python数据分析笔记

————find: 查找元素位置————

查找字符串片段在字符串的下标位置，从前—往后找，返回的第一个被找到字符串片段起始位置

第一个参数： 要查找的字符串片段

第二个参数： 要查找的起始点

第三个参数： 要找到终止位置-1

如果查找的字符串存在多个，查找结果是第一个出现的字符串下标

找不到就返回-1

count： 统计字符串片段， 在字符串中的出现的次数找不到返回0

——示例：——

 s1 = "pythonMuzhou"
​
 print(s1.find("o",6,11))
​
 print(s1.count("o",6.11))
​
​

————字符串常用方法 ：————

replace：替换指定的字符串片段

参数1： 要替换的字符串片段

参数2： 替换之后的字符串片段

参数3： 替换的次数， 从前往后替换（默认替换所有的）

upper： 将小写字母转换为大小

lower： 将大写字母转换成小写

——示例：——

 s1 = "python to muzhou"
​
 res = s1.replace('o','TT',1)    # 替换操作,1表示第几个
​
​
​
 res2 = s1.upper()  # 将小写全部转换成大写
​
 res3 = s1.lower:() # 将大写全部转换成小写

————字符串常用方法 2：————

split: 指定分割点对字符串进行分割

参数1： 分割点

参数2： 分割的次数（默认找到所有的分割点进行分割）

strip： 去除字符串首尾的空格

s2 = ' python:666 '

——示例：——

 s1 = "111ab222ab333ab444"
​
 print(s1.split('a',2))       #将字符串， 用规定的字符“a”进行分割， 得到一个列表,2 表个数
​
​
​
 s2  = '                        python:666                                    '
​
 print(s2.strip())            #去除字符串首尾空格
​
​
​
 s3  =  '6666python6666'
​
 print(s3.strip(6))
​
​
​
 s4  = '              python:6666       muzhou:777777'
​
 print(s4.replace(' ',' '))

————传统的格式化输出方法：%————

%s ：为字符占位，任意类型都可以

%d ：为数值类型占位

%f : 为浮点数占位

s1 = "%s---%d---%f"%('a','b','c')

F表达式 (F，f都一样，python3.6以上支持)

name = '小明'

age = 18

s3 = F"我的名字{name}. 年龄{age}"

print(s3)

——示例：——

 s1 = '我%s你'%('爱')
​
​
​
 s2 = '我的成绩%d'%(100)
​
​
​
 s3 = '我的零花钱%f'%(99.99)

————字符串format的进阶用法————

len（） : 字符串的长度

format ： 格式化输出（进阶)

1.格式化小数长度（会四舍五入） ：.2f

2.将小数按百分比的形式显示 ：.2%

s = 3.6567

——示例：——

 s  = "python"
​
 print(len(s))
​
​
​
 s = 3.6567
​
 print("今天橘子{:.2f}一斤".format(s))
​
​
​
 x = 5.6567
​
 print("今天橘子{1:.2f}一斤".format(s,x))
​
​
​
 print('百分比为{:2% }'.format(0.23455))

————定义列表 List（）————

列表：

1. 定义列表

2. 列表的下标

3. 列表取值

——示例：——

 list = [1,2,3,4,"我爱你",[10,20,30]]
​
 print(list[5][1])

————列表长度len（）————

1.列表的长度len()

2.更新列表中的值

list_1 = [20,30,40,50,60,70]

——示例：——

​
​
 list_1 = [20,30,40,50,60,70]
​
 print(len(list_1))
​
​
​
 list_1[2] = 99
​
 print(list_1)

———列表的加法和乘法操作———

——示例：——

 list_1 = [10, 20, 30]
​
 list_2 = [5, 6, 7]
​
 print(list_1 + list_2)
​
 print(list_1 * 3)
​
​
​
 s5 = "我爱你"*5
​
 print(s5)

####

————列表的切片取值————

列表的切片取值

——示例：——

 list_1=[10,20,30,40,50,60,70]
​
 print(list_1[0:3])    # [10, 20, 30]
​
 print(list_1[-3:-1])   #[50, 60]
​
 print(list_1[-3:])    #[50, 60, 70]
​
 print(list_1[:])    #[10, 20, 30, 40, 50, 60, 70]
​
 print(list_1[1:6])    #[20, 30, 40, 50, 60, ]
​
 print(list_1[-1:6:2])    #[20, 40, 60]
​
 print(list_1[-6:-1])    #[20, 30, 40, 50, 60 ]
​
 print(list_1[-6：-1:2])    #[20, 40, 60]
​
 print(list_1[:-1])    #[70, 60, 50, 40, 30, 20, 10]

————列表的操作方法：————

1.del关键字 删除

2.append方法

append函数用于向列表末尾添加元素

——示例：——

a = [1, 2, 3]
#del = a  #在计算机(内存)当中a变量定义列表 删除
#del a[1]  #删除掉 列表中的制定值
​
a.append(4)
print(a)   #[1, 2, 3, 4]
​

———列表的操作方法 ：———

1.insert方法

insert函数用于向列表中插入元素

insert函数的第一个参数是插入的位置，第二个参数是要插入的对象

2.clear函数用于将列表清空

——示例：——

list_1 = [20, 30, 40, 50]
list_1.insert(2,[1, 2, 3])
​
print(list_1) #[20, 30, [1, 2, 3], 40, 50]
​
list_1.clear()
print(list_1)
print(len(list_1))

———列表操作方法：———

1.remove函数

remove函数用于从列表移除元素。

注意：(执行结果如下.可以看到.若列表中有重复元素.remove函数只会移除匹配到第一个)

2.pop函数

pop函数用于移除列表中指定位置的元素， 并返回要移除的元素

在默认情况下. 移出列表中最后一个元素

——示例：——

a = ["hello","world","python","hello"]
a.remove("hello")
print(a)           #["world","python","hello"]
​
a.pop(3)   #指定的移除
print(a)   #["hello","world","python"]
​
​
print("要移除的数据:",a.pop(3))     #要移除的数据:hello
print("已经更改后的列表",a)          #已经更改后的列表:["world","hello","python"]

———列表的操作方法：———

1.index函数

index函数用于返回所匹配的元素的索引该函数的

第一个参数是待查找的对象

第二个参数是查找的起始范围

第三个参数是查找的结束范

2.reverse函数

reverse函数用于将列表反向排列

——示例：——

a = ["hello","world","hello",python]
r = a.index('hello')
print(r)    #索引到位置0
​
r2 = a.index('hello',1,3)
print(r2)
​
print(a[::-1])        #使a相反
# a.reverse()
# print(a)            

———列表操作方法：———

extend 方法

extend函数用于在列表的末尾添加另一个列表

与append函数相比。extend函数可以一次性添加多个元素

注意:(使用extend函数和列表加法的结果是一样的。但是extend函数会将另一个列表并入当前列表。而列表加法是返回新的列表。为节约内存空间。更推荐使用extend函数来实现大列表的链接操作)

——示例：——

a = [10,20,30]
a.extend(1,2,3)
print(a)   #[10,20,30,1,2,3,]
​
a.append([1,2,3])
print(a)   #[10,20,30,[1,2,3]]
​
b = [1,2,3]
c = a + b
print(c)
​

———列表操作方法： ———

copy函数

copy函数用于创建列表的副本

——示例：——

a = ["hello","world","hello","python"]
b = a.copy()
del a[0]
print('删除a[0]元素之后,输出b列表:',b)
​
#输出["hello","world","hello","python"]
​
a = ["hello","world","hello","python"]
b = a
del a[0]
print('删除a[0]元素之后,输出b列表:',b)
​
#输出["world","hello","python"]

#

———列表的操作方法：———

sort函数用于将列表进行排序

ascii码科普

常见ASCII码的大小规则：0~9<A~Z<a~z

——示例：——

a = ["hello","我","world","hello","python"]
a.sort()
print(a)
​
b = sort(reverse=True)  #倒序
print(b)

———列表的操作方法：———

count函数

count函数用于攻击某个元素在列表中出现的次数

a = ["hellp",""workd","hello","python"]

——示例：——

a = ["hellp",""workd","hello","python"]
r = a.count("hello")
print(r)

————Tuple(元组)————

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号（）里，元素之间用逗号隔开，组中的元素类型也可以不相同

元组：

1.元组也是一种数据容器，使用小括号”（）“表示，其实使用场景与列表相似。这意味着能使用列表的地方，基本上都能使用元组，包括列表推导式，切片等操作。元组与列表的唯一区别是元组不可改变。

2.元组的元素类型可以不统一

——示例：——

letters = ('a','b','c','d','e','f','g')
print(letters[0])  #输出'a'
print(letters[0:3])   #输出一组('a','b','c')
​
​
​
t = ("hello",66,-20,3.66,[10,20,30])
print(t[1:4])  #(60.-20.3.66)

———元组的拼接———

——示例：——

t1  =  ("hello","world","python")
​
t2  =  ([1,2],[3,4],[5,6,7,8])
​
print(t1 + t2)
​
​
t3 = t1 + t2
t3[3][0] = 123
print(t3)   #("hello","world","python"[123 ,2],[3,4],[5,6,7,8])

———关于元组/列表/字符串的一些共同操作———

len（）max（）min（）

——示例：——

a = (1, 2, 3, 4)
print(len(a))   #元组的个数
print(max(a))   #元组最大的值
print(min(a))   #元组最小的值
​
b = [10,20,30,40]
print(len(a))   #元列表的个数
print(max(a))   #列表最大的值
print(min(a))   #列表最小的值
​
c = "12345我abcAABC"
print(len(a))   #字符串表的个数  字符转ascii
print(max(a))   #字符串最大的值
print(min(a))   #字符串最小的值
​

———关于元组的注意事项以及乘号的使用———

——示例：——

#元组
a = (1, 2, 3, 4)
​
b = 10, 20, 30
​
c = (10,)  #括号里只有一个数据加上逗号才是元组
​
d = (20,)
print(d *10) #(20, 20, 20, 20, 20, 20)

————集合————

集合（set）是一个无序不重复元素的序列，使用大括号{}或者set（）函数创建集合，注意：创建一个空集合必须用set（）而不是（），因为{}是用来创建一个空字典。

集合不能被切片也不能被索引，除了做集合运算之外，集合元素可以被添加还有删除：

集合：

集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合中默认去重创建集合

1. 变量名=set（元素） 字符串/列表/元组/字典

2. 变量名={元素，元素，，，} 元组/字符串/数字

3. 元素是唯一的。用于列表的去重

——示例：——

#字符串
a = set("1234")
print(a)  #{'1', '2', '3', '4'}
​
#列表
b = set([10, 20, 30])
prnt(b)   #{10, 20, 30}
​
#元组
​
c = set((1,2,3,4))   
print(C)   #{1 , 2 , 3 ,4}
​
#字典
​
d = {
    "年龄":18,
    "名字":"小明"
}
f = set(d) #{'年龄','名字'}
print(f)
​
#用大括号创建集合
aa = {1,2,3,(1,2,3),"123",}
print(aa)   #{1,2,3,(1,2,3),"123",}
​
#列表的去重
a = set(1,2,1,1,1,1)
print(a)   {1,2}
​
#相同的字符串和列表
abc = {1,2,1,1,"1211"}
print(abc)
​
​

——— 集合添加元素的方法———

1.add（）

往集合中添加元素 数字/字符串/元组

2.update

update可以将集合合并

集合的排列随机排列

——示例：——

a = {1, 2, 3}
a.add(6) #数字 {1, 2, 3, 6}
a.add("小明老师") #字符串{1,2,3,'小明老师'}
print(a)
​
b = {"w","b","a"}
a.update(b)
print(a)

——— 集合删除元素的方法———

1.remov

使用remove删除集合中的元素 如果直接删除 如果没有程序报错

2.pop

使用pop删除是随机删除集合中的元素 弱国集合没有元素程序报错4

3.discard

使用discard 删除 如果元素存在直接删除 如果元素不存在不做任何操作

——示例：——

a = {“python", "学", "小明"}
a.remove("学")
print(a)
​
​
a.pop()
print(a)  #随机的
​
a.discard("学")
print(a)

——— 集合的交集和并集———

1.交集

使用"&"符号连接多个集合。得到相同的元素

2.并集

使用"|"符合连接多个集合。得到集合中的全部数据

——示例：——

s1 = {1,2,3,5}
s2 = {1,2,6,7}
s3 = s1 & s2
s4 = s1 | s2
print(s3)   #{1,2}
print(s4)   #{1,2,3,5,6,7}

——— Dictionary(字典) ———

字典是一种映射类型，它的元素是健值对，字典的关键字必须为不可变类型，且不能重复。创建空字典使用{}。

字典是一种映射类型，它的元素是健值对，字典的健必须为不可变类型，且不能重复健可以是任意不可变类型(元组/字符串/数字)

1. 字典的创建方式

1.1 直接使用"{}"

1.2 使用dict()

2. 空字典

——示例：——

a = {
    "姓名":"小明",
    1：18
    (1,2,3):"123"
}
​
b = dict((["年龄","18"]，["名字","小明"]))
​
print(a)
print(b)
​
c = {}   # 直接写大括号 表达的是字典
​
#集合
d = set()
print(d)

——— 字典的 增删改查的操作 ———

增加

删除

修改

查找(获取)

——示例：——

d = {"名字":"，小明","年龄":18}
d["技能"] = "python技能"   #字典 增加操作
​
del d["技能"]   #字典 删除操作  del 关键字
​
d["名字"] = '小明'   #字典修改操作
​
print(d["年龄"])    #获取到 对应的值
 
​

——— 字典的操作方法 ———

1. get函数

get函数用于从字典获取指定键的值。在get函数中可以设置默认值，当get函数没有获取到对应键时，get函数会将默认值返回

2. keys函数

keys函数将以列表的形式返回字典中的所有键

——示例：——

d = {
    "姓名":"小明",
    ”年龄：18
}
r = d.get("名字")
r1 = d.get("技能")  # None
r2 = d.get("技能","python技能")  # python技能
print(d)
​
f = {
    "姓名":"小明",
    ”年龄：18,
    "技能":{
        "技能1":"python",
        "技能2":"java"
    }
}
print(f.keys())   # (['名字','年龄','技能'])
​

——— 字典的操作方法 ———

3.items函数

items函数’将以列表的形式 返回字典中的所有键值对

4. values函数

values函数将以列表的形式返回字典中的所有值，如下

——示例：——

d = {
    "名字":"小明",
    "年龄":18
}
r = d.items()   #([('名字','小明'),('年龄',18)])
r1 = d.values()  #(['小明',18])
print(r)

——— 字典的操作方法 ———

5. clear函数

clear函数用于将字典清空

6 . copy函数

copy函数用于创建字典的副本，修改原字典对象，不会影响其副本。

——示例：——

d = {
    "名字":"小明",
    "年龄":18
}
​
d.clear()
print(d)   #{}
print(len(d))   #0
​
d2 = {
    "名字":"小明",
    "年龄":18
}
​
d3 = d2.copy()
del d2["名字"]
print(d2)   #{'年龄':'18'}
print(d3)   #{'名字':'小明','年龄':18}

——— 字典的操作方法 ———

7.formkeys函数

formkeys函数用于创建一个新的字典

第一个参数是一个序列（列表/元组/集合）。用于作为字典的键。

第二个参数可以是任何数据类型，作为每个键的值

8.pop函数

pop函数用于从字典中移除指定键，并返回该键所对应的值

——示例：——

d = {}
d1 = d.fromkeys(("，名字":"年龄"))   #{'名字':None,'年龄':None}
​
d2 = d.fromkeys(("，名字","年龄"):(1,2))   #{'名字':(1,2),'年龄':(1,2)}
print(d1)
​
​
d = {
    "名字":"小明",
    "年龄":18
}
​
d.pop('名字')
print(r)  #小明
print(d)  #{'年龄':18}

——— 字典的操作方法 ———

9 .popitem函数

popitem函数用于从字典中删除最后一项，并以元组形式返回该项所对应的键和值

10 .setdefault函数

setdefault函数用于设置键的默认值。

若在字典中该键已经存在，则忽略设置：若不存在，则添加该键和值

d.setsetdefault（键，值 ）

#####

——示例：——

d = {
    "名字":"小明",
    "年龄":18
}
r = d.popitem()
print()   #('年龄':18)
print(d)   #{'名字':'小明'}
​
​
d2 = {
    "名字":"小明",
    "年龄":18
}
​
d2.setdefault("技能","python技能")  #{'名字':'小明','年龄':18，'技能'：'python技能'}
print(d2)

——— 字典的操作方法 ———

、

10.update函数

update函数用于将字典2的值更新到字典1

ruozidian2 的键在字典1已经存在，则对字典1进行修改：

若不存在，则对字典1进行添加

——示例：——

d1 = {
    "名字":"小明"
}
d2 = {
    "名字":"刘亦菲"
}
​
d1.update(d2)   #{'名字':'刘亦菲'}
print(d1)
​
d1 = {
    "名字":"小明"
}
d2 = {
    "年龄":18
}
d1.update(d2)   #{'名字':'小明','年龄':18}
print(d1)

——— 成员检测与标识号检测 ———

使用"in" 和"not in"运算符来判断某个对象是否为序列的成员

in ：判断对象是否在序列（列表/字符串/元组/字典）中，如果是则返回Ture

not in：判断对象是否不在序列中，如果是则返回True

——示例：——

print("4" in "1234")   #字符串4是否存在于字符串"1234"当中
print(1 in (1,2,3,4))
print(1 in [1,2,3])
print("名字" in {"名字":"小明"})
​
# not in  不存在
print(3 not in (1,2,9))   # 3 不在元组当中
print(4 not in ([1,2,4,6]))   #4不在列表当中吗  ？
​

——— 判断两个对象是否相同 ———

判断某两个对象是否相同，则是用is和not is运算符

is（是）判断对象是否相同

is not（不是） 判断对象是否不相同

数字 / 字符串/ 元组 表面一样 完全一样

列表 / 字典 / 集合 表面一样 其实不一样 其实不是同一个对象

——示例：——

a = "小明"
b = "python"
print(a is not b)    #False
​
c = "111"
d = "111"
print(c is d)  #True
​
f = [1]
g = [1]
print(f is g)  False
​
aa = {"名字":"小明"}
bb = {"名字":"小明"}
priint(aa is bb)    #aa跟bb 不是同一个对象了
​
cc = (1,2,3)
dd = (1,2,3)
print(cc is dd)    #True
​
zz = {1,2,3}
xx = {1,2,3}
print(zz is xx)    #False

———python的数据类型转换———

1.1检测数据类型的方法：

type（）

1.2强制类型转换

str（）：可以把其他类型数据转化为字符串类型

注意：所有类型都可以转化为字符串类型。

——示例：——

#检测数据类型:
​
a = "123"
b = 123
c = [1,2,3]
d = (1,2,3)
e = {1,2,3}
f = {"名字":"小明","年龄":18}
g = True
h = 3.14
print(type(a))   # <class 'str'  > -> 数据是 字符串类型
print(type(b))   # <class 'int'  > -> 数据是 int整型
print(type(c))   # <class 'list' > -> 数据是 list列表
print(type(d))   # <class 'tuple'> -> 数据是 typle元组
print(type(e))   # <class 'set'  > -> 数据是 set集合
print(type(f))   # <class 'dict' > -> 数据是 dict字典
print(type(g))   # <class 'bool' > -> 数据是 bool值
print(type(h))   # <class 'float'> -> 数据是 float浮点数值ioiiii

——示例：——

#强制类型转换:
​
a = "123"
​
b = 123
res_b = str(b)
print(res_b,type(res_b))
​
c = True
d = 3.14
e = [1,2,3]
f = (1,2,3)
g = {1,2,3}
h = {"名字":"小明","年龄":18}
​

———python的数据类型转换———

1.1 强制转换类型

int（）：可以把其他类型数据转化为整型

float（）：可以把其他类型数据转化为浮点型

注意：

*数字类型之间可以互相转换

*只有字符串可以转换为数字类型

*并且字符串中的元素必须为传数字，否则无法转换

字符串当中“-3213”-->被处理

——示例：——

a = 123
r_a = float(a)
print(r_a)
​
b = 3.14
r_b  = int(b)   #不遵守 四舍五入
print(r_b)
​
#布尔值 也是 数字
c = True    #代表的数字也就是1
r_c = int(c)   # 1
r_c = float(c)   # 1.0
print(r_c)
​
d = False   # 0
r_d = int(d)
f_d = float(d)   # 0.0
print(r_d)   # 0
​
e = "345"
r_e = int(e)
print(r_e)

———python的数据类型转换———

其他类型转数字类型中有一个特殊情况，就是其他类型转换布尔型

bool（）可以把其他类型转为True或False

1.容器类型转布尔型：

容器类型数据：字符串，列表，元组，字典，集合

i 非容器类型数据：数字类型，布尔类型

容器中为空-->False

容器中有元素-->True

2.数字类型转布尔类型：

int类型中。0为False。其他为真

float类型中，0.0为False，其他为真

——示例：——

a = ""   #空字符串
b = []   #空列表
c = ()   #空元组
d = {}   #空字典
e = set()   #空集合
print(bool(a),bool(b),bool(c),bool(d),bool(e))

———python的数据类型转换———

list()

1. 数字类型是非容器类型，不能转换为列表

2. 字符串转列表时，会把字符串中的每一个字符当作列表的元素

3. 元组 转列表时，会把元组中的每一个字符当作列表的元素

4. 字典 转列表时，只保留字典中的键

5. 集合 转列表时，结果时无序的，因为集合本身就是无序的

——示例：——

a = 123
print(list(a))   #[1,2,3]
​
b = "abcd1234"   #[a,b,c,d,1,2,3,4]
print(list(b))
​
c = (1,2,3,"abcd")   #[1,2,3,'abcd']
print(list(c)) 
​
d = {
    "名字":"小明",
    0:1,
    (1,2,3):18
}
r = list(d)   #['名字'.0,(1,2,3)]
print(r)
​
e = {1,2,3,4,"a","wo"}
r_e = list(e)   #[1,2,3,4,'wo','a']
print(e)  

———python的数据类型转换———

tuple():其他类型数据转换元组类型与其他类型数据转列表类型的规则相同。

1.数字类型是非容器类型，不能转换为元组

2. 字符串转元组时，会把字符串中的每一个字符当作元组的元素

3. 列表转元组时， 会把列表中的每一个元素当作元组的元素

4. 字典转元组时， 只会保留字典中的键

5. 集合转元组时， 结果时无序的，因为集合本身就是无序的

——示例：——

a = 123
#print(tuple(a))   #会报错，数字转不成元组
b = "abc"
#print(tuple(b))   
c = [1,2,3]
#print(tuple(c))
d  = {
    "名字":"小明",
    "年龄":18
}
#print(tuple(c))   #只会保留"名字"和"年龄"
e = {1,2,'我爱你',6,"abc"}
print(tuple(e))
​
​

———python的数据类型转换———

set()其他数据类型转集合类型

1.数字类型时非容器类型，不能转换为集合

2.字符串转集合时，结果是无序的

3.列表转集合时，结果是无序的

4.元组转集合时，结果是无序的

5.字典转集合时,只保字典中的键，结果是无序的

——示例：——

a = 123
#print(set(a))   #不可以转换
​
b = "abc123我爱你"
#print(set(b))
​
c = [1,2,3,"我","a"]
#print(set(c))
​
d = (1,2,'我爱你',6,"abc")
#print(set(d))
​
e = {
    "名字":"小明",
    "年龄":18,
    0:1,
    5:8
}
#print(set(e))

———python的数据类型转换———

dict()其他转字字典类型

1.数字类型是非容器类型，不能转换为字典

2.字符串不能转字典类型，因此字符串不能生成二级容器

3.列表类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2

4.元组类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2集

5.集合并与能转字典类型

——示例：——

a = 123
#print(dict(a))   #不可以转换
​
b = "abc123我爱你"
#print(dict(b))   #字符串不可以转换
​
c = [1,2,3,"我","a"]
#print(dict(c))
​
d = (1,2,'我爱你',6,"abc")
#print(dict(d))
​
e = {1,2,'我爱你',6,"abc"}  
#print(dict(e))   #集合不能转换为字典

———isinstance（）判断———

isinstance（）用来判断一个对象是否是一个已知的类型

isinstance（）函数的返回值是布尔型

若对象的类型是已知的类型，那么就返回True，否则返回False

语法如下：

isinstance（对象，对象类型）

int（整数）float（浮点型） bool（布尔值）str（字符串）

list（列表）Turple（元组） set（集合） dict（字典）

——示例：——

a = 123
print(isinstance(a,int))
b = 123.68
c = True
d = "abc123我爱你"

———— 循环————

———python的条件语句———

if.....elif......else....分支语句

条件必须是真值，才能运行if里面的语句

if 语句是可以单独存在的

if elif(无数个) else

if else

——示例：——

if 3>7:
    print("你好")
elif 3>2:
    print("小明")
elif 3>4:
    print("小李")
else:
    print("不满足")

———python的条件语句———

if....elif.....else....分支语句（如果语句）

条件必须是真值，才能运行if里面的语句

if 语句是可以单独存在的

if elif（无数个）else

if else

——示例：——

if 3>6:
    print("你好")
elif 4>1:
    print("小明")

———python的条件语句———

if....elif.....else....分支语句

——示例：——

a = int(input("请输入你的成绩："))
if a >= 85:
    print("优秀学生")
elif a >= 75:
    print("优良学生")
elif a >= 60:
    print("一般学生")
else:
    print("成绩不及格")

———python的条件语句———

1. for

for循环用来遍历序列。

通过不使用下标的方式来实现对序列中每一个元素的访问

列表/元组/字符串/字典/集合

遍历数字range（）

——示例：——

for i in [1,2,3]:
    print(i)    #1  2  3
    
for i in{"名字":"小明","年龄":18}:
    print(i)     #名字  年龄
    
for i in range(0,10):   #  0-10区间 0123456789
    print(i)

———python的条件语句———

python的for循环语句

1 .遍历字典的 键 和 值 d.items()

2 .range函数的步长

——示例：——

d = {
    "名字":"小明",
    "年龄":18
}
​
for i in d:
    print(a)
    
    
# range()函数步长  range(0,4) -> 区间 0123
# range(0,6,2) -> 012345 024

———循环关键字———

python的双层for循环if判断

isinstance()用来判断一个对象是否是一个已知的类型

——示例：——

a = [1,2,3,[10,20,30],[50,60,70]]
​
for i in a:
    #print(i)
    #判断， 满足条件 是否是列表
    if isinstance(i,list):
        #提取工作 提取列表中的数据
        for x in i :
            print(x)
​

———循环关键字———

while循环 配合 else 运行

——示例：——

while c<6:
    print(c)
    c += 1  #自我增加  c = c+1
    
else:
    print("c变量的值已经为6，不满足c<6的条件了")

———循环关键字———

break 语句可以跳出 for 和 while 的循环体

continue 语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环

——示例：——

for i in "python":
    print(i)
    break
    
for i in "pythopn":
    if i == "t":
        continue
        print("当前的字母是："i)

———循环关键字———

break 语句可以跳出for 和 while 的循环体。

continue 语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

——示例：——

a = 0
while a<6:
    print("我爱你")
    a+ = 1 
    continue

———循环关键字———

pass 是空语句，是为了保持程序结构的完整性

它用于那些语法上必须要有社么语句，但程序什么也不做的场合。

——示例：——

for i in range(0,10):
    pass   #过
​
while 2>3:
    pass

—————python函数—————

一.函数的定义和调用

创建函数的目的是封装业务逻辑，实现代码的重用。如何创建和调用函数

1.1创建函数的关键字：def

1.2函数的参数

（在之前的章节中，针对各类对象调用了非常多的函数，这些都是python的内建函数。这些函数的功能都是预先设计好的，但在实际生产过程中，使用最多的还是自定义函数）

——示例：——

#  创建函数，用到def关键字，空格 函数名字（变量定义规则一样的）
#1. 创建函数   2. 调用函数
#  定义一个 做 加法运算函数
def abc():
    print("我爱你")
    
abc()    # 小括号里面 用来给我们 传递 参数
​
​
def aa(a):
    print(a)
    
aa("我爱你")
​
​
def bb(a,b):
    print(a+b)
    
bb(100,200)
bb(500,600)
​
​
​

———函数的参数———

python函数的参数具有灵活性，其定义的方法可以接受各种形式的参数，也可以简化函数调用方法的代码。

0. 函数中的pass关键字 保持代码完整性

1. 位置参数

在对函数进行调用的时候，有几个位置参数就需要传递几个参数，否则会触发异常。并且，传入参数与函数参数列表是一 一对应

2. 默认参数

3. 可选参数

4. 可变参数与关键字参数

——示例：——

def abc(a,b):
    print(a+b)
    
    
abc(100,200)