<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns="http://purl.org/rss/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel rdf:about="https://blog.x-tools.top/feed/rss/category/python/">
<title>小夏的猪窝 - Python</title>
<link>https://blog.x-tools.top/category/python/</link>
<description>Python随笔</description>
<items>
<rdf:Seq>
<rdf:li resource="https://blog.x-tools.top/archives/27/"/>
<rdf:li resource="https://blog.x-tools.top/archives/13/"/>
<rdf:li resource="https://blog.x-tools.top/archives/12/"/>
</rdf:Seq>
</items>
</channel>
<item rdf:about="https://blog.x-tools.top/archives/27/">
<title>Python - 函数定义 参数形式</title>
<link>https://blog.x-tools.top/archives/27/</link>
<dc:date>2022-06-05T08:38:00+00:00</dc:date>
<description>&lt;!-- [toc] --&gt;函数def 函数定义关键字形参中 不需要声明类型 方便许多相比其他编程语言，它拥有多种传参方式，非常方便定义def 函数名(形参):
    &quot;&quot;&quot;说明文档 可以用help（函数名）查询&quot;&quot;&quot;
    #函数体    
    #注意缩进
    
函数名(实参)位置参数形参、实参的位置要对应一 一对应关键字参数指定参数赋值在给实参时加入一个赋值语句，指定某个形参收到值调用时，一定注意，先传入位置变量后，才能关键字参数，使用顺序不能反了，反了报错。#如这个例子
def sum(x,y):
    print(x+y)
sum(y=89,x=123)默认参数定义def sum(a=123,b=345)这样定义函数头在调用时，就可以不传参因为函数默认a为123 ，b为345可变参数位置可变参数接受所有位置参数，之后返回元组形参有多少参数，实参就有多少参数def name(*args):
    print(args)
name('这是位置可变参数',1,2,3)

#返回 ('这是位置可变参数', 1, 2, 3)
#一个元组关键字字典可变参数接受所有关键字参数，之后返回字典相比位置可变参数，多了一个*号函数收到的是一个字典def name(**args):
    print(args)
name(a='这是关键字可变参数',b=1,c=2,d=3)
#返回 {'a': '这是关键字可变参数', 'b': 1, 'c': 2, 'd': 3}
#是一个字典 键值对注意变量不可以在函数外调用变量定义在函数外，则为全局变量，函数内可用如果必须更改 通常在函数中 声明变量为外部变量global a通常不建议在函数中更改外部变量函数返回值返回值可以返回多个变量，用逗号分割即可。返回多个参数，接受变量为一个时，变量收到的是一个元组形式的。同上，可以用多参数接受def name(a,b,c,d):
    return a,c

ret = name(a='这是关键字可变参数',b=1,c=2,d=3)
print(ret)
#返回的是 ('这是关键字可变参数', 2)

#字典拆包
a = {'a':1,'b':2,'c':3}
def name():
    return a

x,y,z = name()
print(x,y,z,sep='||')
print(a[x],a[y],a[z],sep='||')函数递归递归就是套娃递归一定要有出口递归加法例子def sum(a):
    if a==1:
        return 1
    return a+sum(a-1) #相当于100+99+98+97 ······ +3+2+1

print(sum(100))#返回 5050</description>
</item>
<item rdf:about="https://blog.x-tools.top/archives/13/">
<title>Python - For、While循环 推导式 公共方法</title>
<link>https://blog.x-tools.top/archives/13/</link>
<dc:date>2022-05-22T10:17:00+00:00</dc:date>
<description>&lt;!-- [toc] --&gt;For循环相当于foreach语句 可以遍历 字符串 列表 元组 语法语法#遍历 字符串 列表 元组 语法
for i in 列表:
    print(i)跳出语句Break 结束循环continue 结束本次循环for else如果用了Break 则不执行else的代码用continue 就执行else的代码for i in 列表:
    #执行代码
else:
    #循环正常结束的代码while循环相比for循环的特点不断运行 直到条件不符合退出while同样也有else continue break语句语句块i = 1 
while(i&lt;=100):
    print(i)
    i += 1
else:
    print('循环结束啦')公共方法len()计算元素长度 ，个数del()或del关键字 删除元素max()最大值min()最小值range() 遍历语句 range(开始下标，结束下标，步长)enumerate(列表，起始编号=0)遍历返回(编号，数据) 返回是元组的方式。    for i,j in enumerate(a,1):
        print(f'下标{i},数据{j}')推导式通常用来简化代码列表推导式c = [i for i in range(11) if i%2 == 0]列表中for循环的每一次的值，都会放到最前面的变量 i 中。#创建从0-10的列表 普通方法
a=[]
for i in range(11):
    a.append(i)#向尾部追加数据
    
#列表推导式 将i后面的过程放到i中
b = [i for i in range(11)]

#列表推导式 步长为2 结果为0 2 4 6 8 10
c = [i for i in range(0,11,2)]

#第二种方法 后面有if语句 余数为零（偶数） if为True时 放到第一个 i 中
c = [i for i in range(11) if i%2 == 0]
#  存到i    for循环字典推导式可以快速合并列表为字典maxvar = {x:y for x,y in a.items() if y&gt;200}同列表推导式，for循环中的每一次值，都会放到前面 x：y 中。a1=[&quot;a&quot;,'b','c','d']
b1=[123,456,789,321]
#遍历短的那个
c = {a1[i]:b[i] for i in range(len(a1))}
c = {a1[i]:b[i] for i in range(4)}
#提取列表中目标数据
a = {'a1':123,'b1':234,'c1':345,'d1':456}
maxvar = {x:y for x,y in a.items() if y&gt;200}
#遍历结束后还是字典 键值对的形式出现集合推导式同以上两个推导式i for i in c都是使用for循环遍历循环叠加带入。c = [2,3,4,4,5,5]
d = {i ** 3 for i in c} #求三次方
d = {i for i in c}</description>
</item>
<item rdf:about="https://blog.x-tools.top/archives/12/">
<title>Python - 字符串 列表 元组 字典 集合</title>
<link>https://blog.x-tools.top/archives/12/</link>
<dc:date>2022-05-20T02:08:00+00:00</dc:date>
<description>&lt;!-- [toc] --&gt;字符串 ' '不可变类型强制类型转化方法 str(数字或变量)​                 int(字符串)字符串输出a ='我爱学Python'
print(f'''多行引号c支持f表达式吗？
这是第二行
这是a的值：{a}
下一行结束啦
exit''')
#f表达式 和c# $表达式一模一样

a = int(a)
＃强制类型转换==上面的程序说明多行输出时，支持f表达式，可以带入变量输出！ 非常的实用！==切片a='我爱学Python'a[0:9] 输出：我爱学Pythona[开始下标:结束下标+1]。a[0:9:1] 输出：我爱学Pythona[0:9:2] 输出：我学yhna[开始下标:结束下标+1:步长]  步长默认为1a[::-1] 输出：nohtyP学爱我步长为 -1 时，倒叙输出字符串。a[-7:-2] 输出：学Pyth都为负数时，从右向左，从-1到-n。字符串常用方法查找方法#查找方法  find
a=&quot;我要查找以下字符串'我爱学Python'，嗨嗨嗨，第二个字符串'我爱学Python',嗨嗨嗨&quot;
#a.find(查找的串,查询起始位置,查询结束位置)
print(a.find(&quot;我爱学python&quot;))#返回 -1 ，因为没找到
print(a.find(&quot;我爱学Python&quot;))#返回 10 ，找到了返回的字符串中的起始下表位置
#反向查找  rfind
print(a.rfind(&quot;我爱学Python&quot;))#返回 32
#查询出现多少次字串  count
print(a.count('我爱学python'))#返回 0，没查到
print(a.count('我爱学Python'))#返回 2，出现了2次字符串修改方法#修改方法  replace
a=&quot;我要查找以下字符串'我爱学Python'，嗨嗨嗨，第二个字符串'我爱学Python'，嗨嗨嗨&quot;
#a.replace(旧串，新串，替换次数)
print(a.replace('我爱学Python','Python'))
#分割方法  split
print(a.split('，'))#返回一个列表
#合并方法 只能合并列表
#字符串.join(字符串列表)
a=['字符串1','字符串2','字符串3']
print('*'.join(a))#返回 字符串1*字符串2*字符串3
print(join(a))#报错！ 必须拥有一个合并字符串
print(''.join(a)) #可以用空字符代替补充方法字符串.strip()去除空格列表[]小知识他是可变类型强制类型转化方法 list(序列)列表的定义vs = [123,456,789]#一个列表 中存的是数字
vs=[]#空列表列表方法查找index()方法 如果不存在则报错count()方法vs = [123,456,789]#一个列表 中存的是数字
#查找
vs.index(123)#返回0下标 如果不存在则报错
#查询出现次数
vs.count(123)#返回1
#len测量列表长度
len(vs)#返回3增加append() 只能增加一个数据 加在最后extend() 只能增加一个列表 在最后insert(pos,val) 指定位置追加数据#增加列表
vs = [123,456,789]#一个列表 中存的是数字
#只能增加一个数据 加在最后
vs.append(123456)#结果为[123, 456, 789, 123456]
#只能增加一个列表 在最后
vs.extend([1,2,3,4,5])#vs的值为[123, 456, 789, 123456, 1, 2, 3, 4, 5]
#指定位置追加数据 
vs.insert(1,8)#vs的值[123, 8, 456, 789, 123456, 1, 2, 3, 4, 5]删除del(vs) 删除整个列表del(vs[0]) 删除指定值vs.pop(pos) 删除指定位置并且返回vs.remove(123)  删除第一个匹配的数据clear() 清空列表#删除变量
vs = [123,456,789]#一个列表 中存的是数字
del(vs)#删除整个列表
del(vs[0])#vs 值为 [456, 789]

vs.pop()#删除指定位置的数据，并且返回 修改vs变量
#返回 789 vs值为 [456]

#删除第一个匹配的数据
vs.remove(123) #返回[456,789]

#清空列表
vs.clear()修改reverse() 列表倒叙排列sort() 列表升序排列sort(reverse=True) 列表降序排列#修改数据
a=[1,2,3,4,5,6,7]

#指定下标修改
a[0]=999 #a值为 [999, 2, 3, 4, 5, 6, 7]
#将列表倒叙排序
a.reverse()#a值为 [7, 6, 5, 4, 3, 2, 1]

#排序sort
a=[1,6,7,8,9,0,2,5,4,3]
#默认升序
a.sort()#a 值 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a.sort(reverse=True)#降序 a 值 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]列表的连接lister = ['12','34','354']
strret = ''.join(lister)列表转元组使用tuple()转换a=[1,2,3,4]
a=tuple(a)元组()不可变类型不可以修改数据只能读强制类型转换用 tuple(序列)单个数组的元组定义a = (1,)
#一定要有一个逗号，不然不是元组类型查询方法和列表相同只有index() 和 count()方法len()方法元组转列表a=(1,2,3,4)
a=list(a)循环 遍历 迭代For循环相当于foreach()语句a=[867,234,678,0,2,4,6]
for i in a:
    print(i)
#依次输出
#867
#234
#678
#0
#2         
#4
#6条件判断语句python一定要注意缩进！    C语言是大括号控制，Python不一样的就是使用缩进。
if 条件:
    语句1
    语句2
elif 条件:
    语句1
    语句2
else:
     语句1
     语句2
     
＃三目运算
a = b if a&gt;b else a
＃求两数小值
＃符合条件值 if 条件 else 不符合的值字典{Key:values}可变类型字典总是成对出现的， 统称 键值对字典的定义： a = {}字典的type类型是：dict字典={'huawei':33,'xiaomi':44,'ipad':22}#调用方式
字典['huawei'] #输出33字典的方法增加字典[键]=值
#如果存在 则修改  不存在 则添加删除删除用del进行删除#删除指定值
a={'huawei':1,'xiaomi':2,'ipad':3,'sanxing':4}
del a['ipad']
#删除整个字典
del a
#字典的清空
a.clear()查询get()方法  查询values()方法  返回字典中的值items()方法  返回的是个元组keys()方法  返回所有键 ‘dict_keys’#查询 get
a={'huawei':123,'ipad':321,'xiaomi':546}
a.get('huawei',9999) #返回123
#如果不存在 就返回参数2中的任意值

#values()
#返回字典中的值，返回的是个列表 类型是 dict_values

#items()
#返回的是个元组字典的循环遍历a={'huawei':123,'ipad':321,'xiaomi':546}
#打印遍历所有字典中的键
for i in a.keys():
    print(i)
    
#打印遍历所有字典中的值
for i in a.values():
    print(i)
    
#打印遍历所有字典中的键值对 元组的形式 
for i in a.items():
    print(i)
    
#打印遍历所有字典中的键值对 键值对的调用形式
#就是临时变量多一个 一个是键 一个是值
for i,j in a.items():
    print(f'{i}={j}')集合{}可变类型集合 字典 都是大括号空集合 必须用set()的方法定义类型为set强制转换方法是set()特点没有重复，自动去重顺序是随机的集合的方法增用add()方法增加新集合，加入数据存在则无视。用update()方法追加数据，可以是列表,集合，加入数据存在则无视。a={1,2,3,4}
a.add(5)#增加

a.update({1,2,3,4,5,6,7})
a.update([1,2,3,4,5,6,7])
a.update(&quot;abc&quot;)删remove() #不存在报错discard() #不存在不报错pop() #随机删除集合里的数据a={1,2,3,4}
a.remove(5) #会报错
a.discard(1) #不报错

a.pop()#随机删除一个数据 并且返回删除的数据
#可以这么用
b=a.pop() #删的数据存到b中查用关键字 in 查询数据在集合中用关键字 not in 查询数据不在集合中a={1,2,3,4}
print(1 in a)
print(5 in a)
print(1 not in a)
print(5 not in a)</description>
</item>
</rdf:RDF>