备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

python语法学习（中）

2022-12-10 154
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： python语法学习

1670682839737.jpg


2.列表的查询操作

1670682857136.jpg

'''创建列表的第一种方式，使用[]'''
lst=['hello','world',98,'hello']
print(lst.index('hello'))#如果列表中有相同元素只返回列表中相同元素的第一个元素的索引
#print(lst.index('Python'))#ValueError
#print(lst.index('hello',1,3))
'''创建列表的第二种方式，使用内置函数list()'''
print(lst.index('hello',1,4))
lst=['hello','world',98,'hello','world',234]
print(lst[2])
print(lst[-3])
print(lst[10])#IndexError list indexout of range

1670682953337.jpg

print('------获取列表多个元素，切片-------')
lst=[10,20,30,40,50,60,70,80]
print('原列表',id(lst))
lst2=lst[1:6:1]
print('切的片段',id(lst2))
print(lst[1:6])
print(lst[1:6:])
print(lst[1:6:2])
print(lst[:6:2])
print(lst[1::2])
print('------step步长是负数的情况--------')
print('原列表：',lst)
print(lst[::-1])
#start=7,stop 省略 step=-1
print(lst[7::-1])

1670682974901.jpg

print('------元素是否在列表中-------')
lst=[10,20,30,40,50,60,70,80]
print(10 in lst)
print(100 not in lst)
print('------列表元素的遍历-------')
for item in lst:
    print(item)


3.列表元素的增、删、改操作

1670682995082.jpg

print('------在列表末尾添加元素-------')
lst=[10,20,30]
print('before',lst,id(lst))
lst.append(100)
print('after',lst,id(lst))
#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)
lst3=[True,False,'hello']
#在任意位置上添加N多个元素
lst[1:]=lst3
print(lst)

1670683011310.jpg

lst=[10,20,30,40,50,60,30]
lst.remove(30)#从列表中一处一个元素，如果有重复只移除第一个元素
print(lst)
#lst.remove(100)#VlaueError:list.remove(x):x not in list
#pop()根据索引移除元素
lst.pop(1)
print(lst)
#lst.pop(5) #IndexError :pop index out of range 如果索引位置不存在，将抛出异常
lst.pop()#如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)
print('-------切片操作-删除至少一个元素，将产生一个新的列表对象------')
new_list=lst[1:3]
print('原列表',lst)
print('切片后的列表',new_list)
'''不产生新的列表对象，而是删除原列表中的内容'''
lst[1:3]=[]
print(lst)
'''清楚列表中的所有元素'''
lst.clear()
print(lst)
'''del语句将列表对象删除'''
del lst
print(lst) #name 'lst' is not defined

1670683035209.jpg

lst=[10,20,30,40]
#一次修改一个值
lst[2]=100
print(lst)
lst[1:3]=[300,400,500,600]
print(lst)


4.列表元素的排序

1670683052562.jpg

lst=[20,40,10,98,54]
print('排序前的列表',lst,id(lst))
#开始排序，调用列表的对象的sort方法，升序排序
lst.sort()
print('排序后的列表',lst,id(lst))
#通过指定的关键字参数，将列表的元素进行降序排序
lst.sort(reverse=True)#reverse=True 表示降序排序，reverse-false就是升序排序
print(lst)
lst.sort(reverse=False)
print(lst)
print('---------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象-------')
lst=[20,40,10,98,54]
print('原列表',lst)
#开始排序
new_list=sorted(lst)
print(lst)
print(new_list)


5.列表推导式

1670683080216.jpg

lst=[i*i for i in range(1,10)]
print(lst)
'''列表中的元素的值2，4，6，8，10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)


第七章 夫妻站


0.本章总结

1670683109800.jpg


1. 什么是字典

1670683117032.jpg

1670683124599.jpg


2.字典的原理

1670683133928.jpg


3.字典的创建与删除

1670683140806.jpg

'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))
'''第二种创建dict()'''
student=dict(name='jack',age=20)
print(student)


4.字典的查询操作

1670683172862.jpg

scores={'张三':100,'李四':98,'王五':45}
'''第一种方式，使用[]'''
print(scores['张三'])
#print(scores['陈六']) #KeyError:‘陈六’
'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('陈六'))
print(scores.get('麻七',99))


5.字典元素的增、删、改操作

1670683191845.jpg

scores={'张三':100,'李四':98,'王五':45}
'''key的判断'''
print('张三' in scores)
print('张三' not in scores)
del scores['张三']#删除指定的key-value对
#scores.clear() #清空字典的元素
print(scores)
scores['陈6']=98 #新增元素
print(scores)
scores['陈6']=100#修改元素
print(scores)

1670683210499.jpg

scores={'张三':100,'李四':98,'王五':45}
#获取所有的key
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys))#将所有的key组成的试图转换成列表
#获取所有的value
values=scores.values()
print(values)
print(type(values))
print(list(values))
#获取所有的key=value对
items=scores.items()
print(items)
print(list(items))

1670683227241.jpg


scores={'张三':100,'李四':98,'王五':45}
#字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

1670683242375.jpg

6.字典推导式

1670683252820.jpg

1670683260123.jpg

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
d={item.upper():price for item,price in zip(items,prices)}
print(d)


第八章 是排还是散


0.本章总结

1670683282535.jpg


1.什么是元组

1670683294617.jpg


2.元组的创建方式

1670683301720.jpg

'''第一种创建方式，使用（）'''
t=('python','world',98)
print(t)
print(type(t))
t2='python','world',98
print(t2)
print(type(t2))
t3='python',
print(t3)
print(type(t3))
'''第二种创建方式，使用内置函数tuple()'''
tl=tuple(('python','world',98))
print(tl)
'''空元组的创建方式'''
'''空列表的创建方式'''
lst=[]
lst1=list()
d={}
d2=dict()
#空元组
t4=()
t5=tuple()
print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

1670683319045.jpg

1670683329227.jpg

t=(10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试t[1]修改为100'''
print(id(100))
#t[1]=100 #元组是不允许修改元素的
'''由于[20，30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变'''
t[1].append(100)#向列表中添加元素
print(t)


3.元组的遍历

1670683346440.jpg

'''元组的遍历'''
t=('python','world',98)
'''第一种获取元组元组的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #tuple index out of range
'''遍历元组'''
for item in t:
    print(item)


4.什么是集合

1670683367554.jpg


5.集合的创建

1670683377858.jpg

'''第一种创建方式使用{}'''
s={2,3,4,5,6,7,8,9}#集合中的元素不允许重复
print(s)
'''第二种创建方式是使用set()'''
s1=set(range(6))
print(s1,type(s1))
s2=set([1,2,3,4,5,6,7,7])
print(s2,type(s2))
s3=set((1,2,4,4,5,65))#集合中的元素是无序的
print(s3,type(s3))
s4=set('python')
print(s4,type(s4))
s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))
'''定义一个空集合'''
s6={} #dict字典类型
print(type(s6))
s7=set()
print(type(s7))


6.集合的增、删、改、查操作


1670683397180.jpg

#集合的相关性操作
s={10,20,30,40,400,60}
'''集合元素的判断操作'''
print(10 in s)# true
print(100 in s)
print(10 not in s)
print(100 not in s)
'''集合元素的新增操作'''
s.add(80)
print(s)
s.update({200,400,300})#一次至少添加一个元素
print(s)
s.update([100,99,8])
s.update((78.64,56))
print(s)
'''集合元素的删除操作'''
s.remove(100)
print(s)
#s.remove(500) #KeyError: 500
s.discard(500)
s.discard(300)
print(s)
s.pop()
s.pop()
#s.pop(400)#set.pop() takes no arguments (1 given)
print(s)
s.clear()
print(s)

1670683417083.jpg

s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)
print(s!=s2)
'''一个集合是否是另外一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1))
print(s3.issubset(s1))
'''一个集合是否是另外一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset())
'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))
s4={100,200,300}
print(s2.isdisjoint(s4))

1670683435930.jpg


'''两个集合是否含有交集'''
print(s2.isdisjoint(s3))
s4={100,200,300}
print(s2.isdisjoint(s4))
'''交集'''
print(s1.intersection(s2))
print(s1 & s2)# 与上面一行是等价的
'''并集'''
print(s1.union(s2))
print(s1|s2) #与上面是一样等价的
'''差集'''
print(s1.difference(s2))
print(s1-s2)
print(s1)
print(s2)
'''对称差集'''
print(s1.symmetric_difference(s2))
print(s1^ s2)


7.集合生成式


1670683461076.jpg

lst=[i*i for i in range(10)]
print(lst)
'''集合生成式'''
s={i*i for i in range(10)}
print(s)


sp:列表、字典、元组、集合总结

1670683479738.jpg


第九章 一串连一串


0.本章总结

1670683496470.jpg


1.字符串驻留机制

1670683504347.jpg

1670683511161.jpg

1670683517984.jpg

在这里插入代码片a='python'
b="python"
c='''python'''
print(a,id(a))#1784692440496
print(b,id(b))#1784692440496
print(c,id(c))#1784692440496


2.字符串的常用操作

1670683536077.jpg

s='hello,hello'
print(s.index('lo'))#3
print(s.find('lo'))#3
print(s.rfind('lo'))#9
print(s.rindex('lo'))#9
#print(s.index('k'))#substring not found
print(s.find('k'))#-1
#print(s.rindex('k'))#substring not found
print(s.rfind('k'))#-1

1670683551494.jpg

s='hello,python'
a=s.upper()#转成大写之后，会产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b-=s.lower()#转换之后，会产一个新的字符串对象
print(b,id(b))
print(s,id(s))
print(b==s)
print(b is s)#False
s2='hello,python'
print(s2.swapcase())
print(s2.title())

1670683569013.jpg

s='hello,python'
'''居中对齐'''
print(s.center(20,'*'))
'''左对齐'''
print(s.ljust(20,'*'))
print(s.ljust(10))
print(s.ljust(20))
'''右对齐'''
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))
'''右对齐，使用0进行填充'''
print(s.zfill((20)))
print(s.zfill(10))

1670683596460.jpg


s='hello world python'
lst=s.split()
print(lst)
s1='hello|world|python'
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))
print('---------------------')
'''rsplit()从右侧开始劈分'''
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|',maxsplit=1))

1670683617848.jpg

s='hello,python'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三_'.isidentifier())
print('4','张三_123'.isidentifier())
print('5','\t'.isspace())
print('6.','abc'.isalpha())
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())
print('9','123'.isdecimal())
print('10.','123四'.isdecimal())
print('11.','123'.isnumeric())
print('13.','123四'.isnumeric())
print('14','abc1'.isalnum())
print('16.','张三123'.isalnum())
print('17.','abc!'.isnumeric())

1670683640577.jpg

s='hello,python'
print(s.replace('python','java'))
s1='hello,python,python,python'
print(s1.replace('python','java',2))
lst=['hello',java,python]
print('|'.join(lst))
print('',join(lst))
t=('hello','java','python')
print('',join(t))


3.字符串的比较

1670683661405.jpg

print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))
print(ord('杨'))
print(chr(97),chr(98))
print(chr(26472))
'''==与is的比较
==比较的是value
is 比较的是id是否相等'''
a=b='python'
c='python'
print(a==b)
print(b==c)
print(a is b)
print(a is c)
print(id(a))#2559352137840
print(id(b))#2559352137840
print(id(c))#2559352137840


4.字符串的切片比较

1670683691435.jpg

s='hello,python'
s1=s[:5]
s2=s[6:]
s3='!'
newtr=s1+s3+s2
print(s1)
print(s2)
print(newstr)
print('--------------------------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))
print('--------切片[start:end:step]----------------')
print(s[1:5:1])#从1开始截取到5（不包含5），步长为1
print(s[::2])
print(s[::-1])#默认从字符串最后一个元素开始，到字符串的第一个元素结束，因为步长是负数


5.格式化字符串

1670683714169.jpg

1670683720522.jpg


#(1) %占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
#(2) {}
print('我叫{0}，今年{1}岁'.format(name,age))
#f-string
print(f'我叫{name},今年{age}岁')
print('%10d' % 99)
print('%.3f' % 3.1415926)
print('%10.3f' % 3.1415926)
print('hellohello')
print('{0:.3}'.format(3.1415926))
print('{0:.3f}'.format(3.1415926))


6.字符串的编码转换

1670683742632.jpg

s='天涯共此时'
print(s.encode(encoding='GBK')) #一个中文占两个字节
print(s.encode(encoding='UTF-8'))#在UTF-8这种编辑格式中，一个中文占三个字节
#解码
#byte代表就是一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))
byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))


第十章 水晶球不调用不动


0.本章总结


1670683770730.jpg

1.函数的创建和调用

1670683777992.jpg

1670683785851.jpg


def calc(a,b):
    c=a+b
    return c
result=calc(10,20)
print(result)


2.函数的参数传递


1670683810334.jpg

1670683817019.jpg


3.函数的返回值


1670683826440.jpg

def fun(num):
    odd=[]#存奇数
    even=[]#存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))
'''函数的返回值
    1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】
    2）函数的返回值，如果是一个，直接返回类型
    3）函数的返回值，如果是多个，返回的结果为元组
'''
def fun1():
    print('hello')
    #return
fun1()
def fun2():
    return 'hello'
res=fun2()
print(res)
def fun3()
    return 'hello','world'
print(fun3())
'''
函数在定义时，是否需要返回值，就视情况而定'''


4.函数的参数定义


1670683851863.jpg

def fun(a,b=10):
    print(a,b)
#函数的调用
fun(100)
fun(20,30)
print()
print('hello',end='\t')
print('world')

1670683867317.jpg

def fun(*args):
    print(args)
    #print(args[0])
fun(10)
fun(10,30)
fun(30,405,50)
def fun1(**args):
    print('hello','world','java')
#def fun2(*args,*a):#以上代码，程序会报错，因为可变参数只能是定义一个
#def fun2(**args,**args):#以上代码，程序会报错，因为可变参数只能定义一个
def fun2(*args1,**args2):#程序可以运行
    pass
#def fun2(**args1,*arg2)#报错
   # pass 在一个函数的定义过程中，既有个数可变的关键字形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前


1670683887456.jpg

def fun(a,b,c):#a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=',b)
    print('c=',c)
#函数的调用
fun(10,20,30)#函数调用时的参数传递，称为位置传参
lst[11,22,33]
fun(lst)#错误
fun(*lst)#在函数调用时，将列表中的每一个元素都转换为位置实参传入
print('---------------')
fun('a=100,c=100,b=200')#函数的调用，所以是关键字实参
fun(**dic)#在函数调用的时候，将字典中的键值对都转换为关键字实参传入
print(-------------------------------------------------------)
def fun(a,b=10):#b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
    print('a=',a)
    print('b=',b)
def fun2(*args):#个数可变的位置形参
    print(args)
def fun3(**args2):#个数可变的关键字形参
    print(args2)
fun2(10,20,30,40)#个数不限
fun3(a=11,b=22,c=33,d=44,e=55)#个数不限
def fun4(a,b,*,c,d):#从*之后的参数，在函数调用的时候，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
#调用fun4 函数
#fun4(10,20,30,40)#位置实参传递
#fun4(a=10,b=20,c=30,d=40)#关键字实参传递
fun4(10,20,c=30,d=40)#前两个参数，采用的是位置实参传递，而c,d采用的是关键字实参传递
'''需求，c、d只能采用关键字实参传递'''
'''函数定义时的形参的顺序问题'''
def fun5 (a,b,*,c,d,**args):#就可以这样定义
    pass
def fun6(*args,**args2):#就可以这样定义
    pass
def fun7(a,b=10,*args,**args2):#可以定义
    pass
文章标签：
Python
关键词：
Python学习
Python语法
Python语法学习
6agucrwnzwl4a
目录
相关文章
龙大吉
|
8天前
|
Python
python函数的参数学习
学习Python函数参数涉及五个方面：1) 位置参数按顺序传递，如`func(1, 2, 3)`；2) 关键字参数通过名称传值，如`func(a=1, b=2, c=3)`；3) 默认参数设定默认值，如`func(a, b, c=0)`；4) 可变参数用*和**接收任意数量的位置和关键字参数，如`func(1, 2, 3, a=4, b=5, c=6)`；5) 参数组合结合不同类型的参数，如`func(1, 2, 3, a=4, b=5, c=6)`。
龙大吉
13 1
ForcibleBugMaker
|
10天前
|
Java 编译器 C语言
Python速成篇（基础语法）上
Python速成篇（基础语法）上
ForcibleBugMaker
55 1
众所周知
|
12天前
|
Python
Python文件操作学习应用案例详解
【4月更文挑战第7天】Python文件操作包括打开、读取、写入和关闭文件。使用`open()`函数以指定模式（如'r'、'w'、'a'或'r+'）打开文件，然后用`read()`读取全部内容，`readline()`逐行读取，`write()`写入字符串。最后，别忘了用`close()`关闭文件，确保资源释放。
众所周知
17 1
find_starshine
|
4天前
|
Python
python学习3-选择结构、bool值、pass语句
python学习3-选择结构、bool值、pass语句
find_starshine
20 0
Echo_Wish
|
2天前
|
机器学习/深度学习 算法 Python
使用Python实现集成学习算法：Bagging与Boosting
使用Python实现集成学习算法：Bagging与Boosting
Echo_Wish
11 0
find_starshine
|
4天前
|
Python
python学习14-模块与包
python学习14-模块与包
find_starshine
18 0
find_starshine
|
4天前
|
Python
python学习12-类对象和实例对象
python学习12-类对象和实例对象
find_starshine
16 0
find_starshine
|
4天前
|
数据采集 Python
python学习9-字符串
python学习9-字符串
find_starshine
7 0
find_starshine
|
4天前
|
Python
python学习10-函数
python学习10-函数
find_starshine
27 0
find_starshine
|
4天前
|
存储 索引 Python
python学习7-元组
python学习7-元组
find_starshine
19 2

热门文章

最新文章

  • 1
    【Python 基础教程 02】 数据类型全解析：从基础到高级，实用指南及详细使用案例
  • 2
    【Python 基础教程 01 全面介绍】 Python编程基础全攻略：一文掌握Python语法精髓，从C/C++ 角度学习Python的差异
  • 3
    使用Python实现DBSCAN聚类算法
  • 4
    在Python Web开发过程中：数据库与缓存，MySQL和NoSQL数据库的主要差异是什么？
  • 5
    Redis与Python的完美结合：实现高效数据交互和应用场景全解析
  • 6
    【Python 基础教程 23】Python3 错误与异常处理全面指南：从入门到精通的实用教程
  • 7
    Python读取.nc文件的方法与技术详解
  • 8
    Pandas基本操作：Series和DataFrame（Python）
  • 9
    【Python 基础教程 运算符06】Python3运算符超详细解析：全面入门教程，初学者必读
  • 10
    【Python 基础教程 05】超详细解析Python3注释：全面入门教程，初学者必读,了解Python如何 进行注释
  • 1
    Python中的装饰器：概念、用法和实例
    18
  • 2
    Python中的装饰器：概念、用法及实例
    17
  • 3
    使用Python实现图像处理中的边缘检测算法
    39
  • 4
    Python中如何实现字符串反转？请提供至少两种方法。
    17
  • 5
    请简述Python中的继承、封装和多态的概念。
    22
  • 6
    在Python中，如何创建一个迭代器？
    19
  • 7
    请解释Python中的迭代器和生成器的区别？并分别举例说明。
    18
  • 8
    在Python中，如何使用装饰器重写类的方法？
    21
  • 9
    Python中的装饰器是什么？请举例说明其用法。
    19
  • 10
    Python中的装饰器：概念、用法及实例
    17

    • 相关课程

    更多
  • Python Web开发基础
  • Python爬虫实战
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 相关实验场景

    更多
  • Python新手入门
  • Python入门
  • Python选择及循环结构
  • Python新手入门（Anolis OS）
  • Python网络通信程序典型应用
    • 下一篇
    阿里云oss简介和使用流程
    为什么选择阿里云什么是云计算全球基础设施技术领先稳定可靠安全合规分析师报告
    产品和定价全部产品免费试用产品动态产品定价价格计算器云上成本管理
    解决方案技术解决方案
    文档与社区文档开发者社区天池大赛培训与认证
    权益中心免费试用高校计划企业扶持计划推荐返现计划
    支持与服务基础服务企业增值服务迁云服务官网公告健康看板信任中心
    关注阿里云
    关注阿里云公众号或下载阿里云APP，关注云资讯，随时随地运维管控云服务
    阿里云APP阿里云微信
    联系我们：4008013260
    法律声明Cookies政策廉正举报安全举报联系我们加入我们
    阿里巴巴集团淘宝网天猫全球速卖通阿里巴巴国际交易市场1688阿里妈妈飞猪阿里云计算AliOS万网高德UC友盟优酷钉钉支付宝达摩院淘宝海外阿里云盘饿了么
    © 2009-2024 Aliyun.com 版权所有 增值电信业务经营许可证： 浙B2-20080101 域名注册服务机构许可： 浙D3-20210002 京D3-20220015
    浙公网安备 33010602009975号浙B2-20080101-4