python基础

最新推荐文章于 2024-09-16 08:54:02 发布

大数据数据分析

最新推荐文章于 2024-09-16 08:54:02 发布

阅读量333

点赞数 5

文章标签：开发语言数据挖掘数据分析 python

本文链接：https://blog.csdn.net/2301_80437783/article/details/137243295

版权

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

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

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

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

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

####

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

#### 找不到就返回-1

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

####

### —*—示例：—*—

```python
s1 = "pythonMuzhou"

print(s1.find("o",6,11))

print(s1.count("o",6.11))

```

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

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

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

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

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

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

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

## —*—示例：—*—

```python
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 '

### —*—示例：—*—

```python
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)
```

![a2fca6af2ad229258167ff8c48f4deb](assets/a2fca6af2ad229258167ff8c48f4deb-1701678573214-3.png)

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

### len（） : 字符串的长度

### format ：格式化输出（进阶)

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

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

#### s = 3.6567

### —*—示例：—*—

```python
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. 列表取值

## —*—示例：—*—

```python
list = [1,2,3,4,"我爱你",[10,20,30]]

print(list[5][1])
```

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

### 1.列表的长度len()

### 2.更新列表中的值

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

### —*—示例：—*—

```python

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

print(len(list_1))

list_1[2] = 99

print(list_1)
```

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

### —*—示例：—*—

```python
list_1 = [10, 20, 30]

list_2 = [5, 6, 7]

print(list_1 + list_2)

print(list_1 * 3)

s5 = "我爱你"*5

print(s5)
```

####

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

### 列表的切片取值

## —*—示例：—*—

```python
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函数用于向列表末尾添加元素

### —*—示例：—*—

```python
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函数用于将列表清空

### —*—示例：—*—

```python
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函数用于移除列表中指定位置的元素，并返回要移除的元素

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

### —*—示例：—*—

```python
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函数用于将列表反向排列

## —*—示例：—*—

```python
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函数来实现大列表的链接操作)

## —*—示例：—*—

```python
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

### —*—示例：—*—

```python
a = ["hello","我","world","hello","python"]
a.sort()
print(a)

b = sort(reverse=True) #倒序
print(b)
```

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

### count函数

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

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

### —*—示例：—*—

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

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

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

### 元组：

####

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

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

### —*—示例：—*—

```python
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)
```

## ———元组的拼接———

### —*—示例：—*—

```python
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（）

### —*—示例：—*—

```python
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)) #字符串最小的值

```

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

### —*—示例：—*—

```python
#元组
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. 元素是唯一的。用于列表的去重

### —*—示例：—*—

```python
#字符串
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可以将集合合并

#### 集合的排列随机排列

### —*—示例：—*—

```python
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.并集

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

### —*—示例：—*—

```python
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. 空字典

### —*—示例：—*—

```python
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函数将以列表的形式返回字典中的所有键

### —*—示例：—*—

```python
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函数将以列表的形式返回字典中的所有值，如下

### —*—示例：—*—

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

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

### 5. clear函数

#### clear函数用于将字典清空

### 6 . copy函数

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

### —*—示例：—*—

```python
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函数用于从字典中移除指定键，并返回该键所对应的值

### —*—示例：—*—

```python
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（键，值）

#####

### —*—示例：—*—

```python
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进行添加

### —*—示例：—*—

```python
d1 = {
"名字":"小明"
}
d2 = {
"名字":"刘亦菲"
}

d1.update(d2) #{'名字':'刘亦菲'}
print(d1)

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

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

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

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

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

### —*—示例：—*—

```python
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（不是）判断对象是否不相同

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

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

### —*—示例：—*—

```python
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的条件语句———

###

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

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

### if 语句是可以单独存在的

### if elif（无数个）else

### if else

### —*—示例：—*—

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

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

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

### —*—示例：—*—

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

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

### 1.1检测数据类型的方法：

#### type（）

### 1.2强制类型转换

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

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

### —*—示例：—*—

```python
#检测数据类型:

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
```

### —*—示例：—*—

```python
#强制类型转换:

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”-->被处理

### —*—示例：—*—

```python
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，其他为真

### —*—示例：—*—

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

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

### list()

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

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

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

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

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

### —*—示例：—*—

```python
a = 123
print(list(a))

b = "abcd1234"
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. 可变参数与关键字参数

### —*—示例：—*—

```python
def abc(a,b,c):
print(a+b+c)


abc(我,爱,你)
#传入的参数可以是任何的数据类型
#注意：函数，先定义函数，在调用
```

## ———函数的参数———

### 2.默认参数、

#### 默认参数是指带有默认值的参数，在对该函数进行调用的时候，可以不必显示传递给该函数。当不传递值的时候，函数将使用默认值

#### 注意：默认值只能会执行一次这条规则在默认值可变对象（列表，字典以及大多数类的实例）时非常重要

#### 官方建议默认参数尽量使用不可变对象！！

#### 因为可变对象会存储在后续调用中传递给它的参数

### —*—示例：—*—

```python
def abc(a=200,b=400):
print(a+b)

abc() # 省略传入所有参数，函数会使用默认参数的默认值

#abc(600) # 为第一个默认参数传入值，另一个默认参数继续使用默认值

#abc(600,300) # 为两个默认参数都掺入值

#abc(b=1000) #指定一个默认参数进行传值

def abc(a,b=[]): # 列表是可变对象
b.append(a)
print(b)

abc(100) # [100]
abc(200) # 期待的是[200] 但是得到的是:[100,200]
abc(300) # 期待的是[300] [100,200,300]

def abc(a,b=None):
if b is None:
b = []
b.append(a)
print(b)
abc(100) #[100]
abc(200) #[100]

```

## ———函数的参数———

### 3.关键字参数

#### 函数调用时，指定参数名称，成为关键字参数（别和默认参数混淆，这里是函数调用）

#### 注意：函数调用时，关键字参数必须在普通参数的后面

### —*—示例：—*—

```python
def aa(x,a=100,b=200): # 默认参数，函数定义的时候传参
print(a+b)

aa(100,a=200,b=600) # 800 # 关键字参数，函数调用的时候
```

## ———函数的参数———

#### 限定关键字形参（命名关键字参数）

#### 特带：必须使用关键字方式传递参数

#### 限定关键字形参，当然就是为了限制后面几个参数只能按关键字传递，这往往是因为后面几个形参名具有十分明显的含义，显示写出有利于可读性：或者后面几个形参随着版本更迭很有可能发生变化，强制关键字形式有利于保证跨版本兼容性

### —*—示例：—*—

```python
def aa(a,b,c): #默认参数后面必须也是默认参数
print(a)
print(b)
print(c)

abc(100)

def aa(a,b=100,c=200): #默认参数后面必须也是默认参数
print(a)
print(b)
print(c)

abc(100,200,300)

def aa(a,b=100,c=200): #默认参数后面必须也是默认参数
print(a)
print(b)
print(c)

abc(100,c=600,b=700)

def aa(a,*,c,d): #默认参数后面必须也是默认参数
print(a)
print(c)
print(d)

abc(100,c=100,d=200) #c,d必须使用关键字传参
```

## ———函数的参数———

### 可变参数：

#### *参数：最常见的变量名时args，看到该变量名，一眼就知道变量args指向一个tuple对象

#### 自动收集所有未匹配的位置参数到一个tuple对象中，变量名args指向了此tuple对象

### —*—示例：—*—

```python
def abc(a,*b):
print(a) # 100
print(b) # b参数对应的是一个空元组（）

abc(100)

def abc(a,*b):
print(a) # 100
print(b) # b参数对应的是一个（200m，）

abc(100,200)

def abc(a,*b):
print(a) # 100
print(b) # b参数（200，300，400，500，600）

abc(100,200,300,400,500,600)
```

## ———函数的参数———

### 可变参数：

#### **参数：最常见的变量名是kwargs，看到该变量名，一眼就知道变量kwargs指向一个dict对象

#### 自动收集所有未匹配的关键字参数到一个dict对象中，变量名开挖如果是指向了此dict对象

### —*—示例：—*—

```python
def abc(a,**b):
print(a)
print(b) #b 指向的是空字典{} 键的值

abc(100,x=200,y=300) #{'x':200,'y':300}
```

## ———函数的参数———

### 参数的解包（拆包）：

#### 参数数据类型是：字符串/列表/元组/集合/字典的时候可以解包

#### 传递实参时，可以在序列类型的参数前添加星号，

#### 这样他会自动将序列中的元素依次作为参数传递

### —*—示例：—*—

```python
s = "123" #字符串
l = [1,2,3] #列表
t = (1,2,3) #元组
s1 = {1,2,3} #集合
d = {
"名字":"小明",
"年龄":18，
"技能"："python"
} #字典

def aa(a,b,c):
print(a)
print(b)
print(c)
aa(100,200,300)

aa(**d) #：后面的
aa(*d) #：前面的

d = {
"名字":"小明",
"b":18，
"c"："python"
} #字典

def abc(名字,b,c):
print(名字) #是对应的
print(b)
print(c)
```

## ———函数的参数———

#### pythond的参数解包和可变参数一起使用

#### 注意：**参数只收集未匹配的关键字参数

### —*—示例：—*—

```python
def abc(a,*args):
print(a)
print(args)
abc(100,(1,2,,3))

d = {
"名字":"小明",
"年龄":18
}

def abc(a,**kwargs):
print(a)
print(lwargs)
abc(100，**d)
```

## ———函数的参数———

### 函数中各种参数排列位置的注意事项

#### 1.可变参数，必须定义在普通参数以及默认值参数的后面

#### 2.函数定义时，二者同时存在，一定需要将*args放在**kwargs之前def abc（普通参数，默认值参数name="小明"， *参数， ** **参数）：

#### pass

### —*—示例：—*—

```python
def abc(a,name="小明"，*args,**kwargs):
print(a) # 100
print(name) #张三
print(args) #(1,2,3,4)

for i in args: #遍历元组当中的每个元素
print(i)

print(kwargs) #{'x':100,'y':200,'z':300}
for key,value in kwargs.items():
print(key)
print(value)

abc(100,"李四",1,2,3,4,x=100,y=200,z=300)

```

## ———函数的参数———

### 函数返回值

#### python中的函数可以使用return返回数据，也可以不用return返回，则默认返回"None"。

return关键字，用来函数执行的时候，帮助我们返回我们处理好的结果

### —*—示例：—*—

```python
def abc():
print("你好")

r = abc() # 函数调用的返回值,可以用变量接受
print(r)

def abc(a):
return a+100
r = abc(900)
print(r) # 1000

def abc(a,b,c):
return a+100,b+200,c+300
r = abc(100,200,300)
print(r) # 返回值是一个元组数据类型(200,400,600)

x,y,z = r # 元组的解包
print(x)
print(y)
print(z)
```

## ———函数的参数———