文章目录
一、列表
1、查找列表元素值索引
index()方法:用于从列表中找出某个值第一个匹配项的索引位置。
语法:listname.index(x,start,end)
- listname-- 列表名
- x-- 查找的对象。
- start-- 可选,查找的起始位置。
- end-- 可选,查找的结束位置。
如:list.index('python')
返回的结果是list列表
中python
这个元素对应的索引值。
2、列表添加元素
①、append()方法:用于在列表的末尾追加元素
语法:listname.append(x)
- listname-- 需要添加元素的列表名
- x-- 添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等。
②、extend()方法:用于在列表的末尾追加元素
语法:listname.extend([x])
- listname-- 需要添加元素的列表名
- x-- 添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等。
- 注意:x的那个[]最好要加上
③、insert()方法:用于在列表中间某个位置插入元素
语法:listname.insert(index, x)
- listname-- 需要添加元素的列表名
- index-- 指定插入位置的索引值
- x-- 添加到列表指定位置的数据,它可以是单个元素,也可以是列表、元组等。
④、合并方法:利用列表的切片操作,将两个列表进行合并。
3、列表删除元素
①、def方法:根据索引值删除元素
语法:def listname[index]
或 del listname[start, end]
- listname-- 需要删除元素的列表名
- index-- 需要删除的元素的索引值
- start-- 起始索引
- end-- 结束索引
- 注意:del 会删除从索引 start 到 end 之间的元素,不包括 end 位置的元素
②、pop()方法:根据索引值删除元素
语法:listname.pop(index)
- listname-- 需要删除元素的列表名
- index-- 需要删除的元素的索引值
- 注意:如果不写 index 参数,默认会删除列表中的最后一个元素
③、remove()方法:根据元素值删除元素
语法:listname.remove(x)
- listname-- 需要删除元素的列表名
- x-- 需要删除的元素
- 注意:remove()方法一次删除一个元素;重复的元素只删除第一个;元素不存在时,会抛出错误。
④、clear()方法:清空列表
语法:listname.clear()
- listname-- 需要删除元素的列表名
4、列表排序
①、sort()方法
语法:listname.sort(reverse=)
- listname-- 需要进行排序的列表名
- 参数reverse-- 为True时,表示降序排序;为Flase时,表示升序排序;默认为升序排序。
②、sorted()方法
语法:sorted(listname, reverse= )
- listname-- 需要进行排序的列表名
- 参数reverse-- 为True时,表示降序排序;为Flase时,表示升序排序;默认为升序排序。
③、两种方法的区别
sort()方法是在原列表的基础上,直接排序,会改变原列表;
sorted()方法会将排序结果保留到新的列表中,原列表不会改变。
5、列表生成式
'''
举一个例子,将偶数筛选出来,放到一个列表里,打印这个列表
'''
# 一般的写法
li1 = []
for i in range(1, 10):
if i % 2 == 0:
li1.append(i)
print('一般写法的输出结果:', li1)
# 列表生成式的写法
li2 = [i for i in range(1, 10) if i % 2 == 0]
print('列表生成式的输出结果:', li2)
结果如下:
一般写法的输出结果: [2, 4, 6, 8]
列表生成式的输出结果: [2, 4, 6, 8]
二、字典
1、字典元素的获取
①、[ ]方法
语法:dictname["key"]
- dictname-- 字典名
- key-- 元素对应键名
②、get()方法
语法:dictname.get("key")
- dictname-- 字典名
- key-- 元素对应键名
③、两种方法的区别
[ ]方法,找不到对应的key,会报一个KeyError错误;
get方法,找不到对应的key,会返回None,也可以通过参数设置,使返回值不是None,而是设定的值。
如:
result = dictname.get("key", 'error')
如果key不是dictname字典中存在的键,那么打印result的结果是error。
2、字典添加元素
①、[ ]方法
语法:dictname[key] = value
- dictname-- 需要添加元素的字典名
- key-- 指定一个dictname字典中不存在的key(如果dictname字典中存在key,则是修改操作)作为添加的元素的key
- value-- 添加的元素的value值
②、update()方法
语法1:dictname.update({key : value})
语法2:dictname.update(key = value)
- dictname-- 需要添加元素的字典名
- key-- 指定一个dictname字典中不存在的key(如果dictname字典中存在key,则是修改操作)作为添加的元素的key
- value-- 添加的元素的value值
3、字典删除元素
①、pop()方法
语法:dictname.pop(key)
- dictname-- 需要删除元素的字典名
- key-- 需要删除元素对应的key
②、del方法
语法:del dictname[key]
- dictname-- 需要删除元素的字典名
- key-- 需要删除元素对应的key
③、clear()方法:用于清空字典
语法:dictname.clear()
- dictname-- 需要清空的字典名
4、获取字典的视图
keys = dictname.keys() # 获取所有key组成的视图
values = dictname.values() # 获取所有value组成的视图
items = dictname.items() # 获取所有key-value对,组成的视图
- dictname-- 字典名
5、字典生成式
示例如下:
'''
将字典的key与value位置互换
'''
dict1 = {
"one": 1, "two": 2, "three": 3}
dict2 = {
value: key for key, value in dict1.items()}
print(dict2)
输出结果:
{
1: 'one', 2: 'two', 3: 'three'}
三、集合
1、集合新增元素
①、add()方法:一次添加一个元素
语法:setname.add(x)
- setname-- 添加元素的集合名
- x-- 添加的元素
②、update()方法:一次添加多个元素
语法:setname.update(x)
- setname-- 添加元素的集合名
- x-- 添加的元素
示例如下:
a = set('str')
a.add('python')
b = set('str')
b.update('python')
c = {
1, 2, 3}
c.add(80)
d = {
1, 2, 3}
d.update([10, 20, 30])
'''
d.update([10, 20, 30]) 也可以写成
d.update({10, 20, 30})
d.update((10, 20, 30))
'''
print(a)
print(b)
print(c)
print(d)
输出结果:
{
'python', 't', 'r', 's'}
{
'n', 'r', 'h', 'o', 'y', 'p', 's', 't'}
{
80, 1, 2, 3}
{
1, 2, 3, 10, 20, 30}
2、集合删除元素
①、remove()方法:删除指定元素
语法:setname.remove(element)
- setname-- 集合名
- element-- 需要删除的元素
②、discard()方法:删除指定元素
语法:setname.discard(element)
- setname-- 集合名
- element-- 需要删除的元素
remove()方法和discard()方法的区别:
使用 remove 方法删除元素时,如果元素不存在集合中,那么程序会报错。
使用 discard 方法删除元素时,如果元素不存在集合中,那么程序不会报错。
③、pop()方法:删除第一个元素,并返回删除的元素
语法:setname.pop()
- setname-- 集合名
④、clear()方法:清空集合
语法:setname.clear()
- setname-- 集合名
示例如下:
a = {
1, 2, 3, 4, 5}
a.remove(2)
print(a)
b = {
1, 2, 3, 4, 5}
b.discard(3)
print(b)
c1 = {
1, 2, 3, 4, 5}
c2 = c1.pop()
print(c1)
print(c2)
d = {
1, 2, 3, 4, 5}
d.clear()
print(d)
输出结果:
{
1, 3, 4, 5}
{
1, 2, 4, 5}
{
2, 3, 4, 5}
1
set()
3、集合生成式
相比与列表生成式,只是将 [ ] 改成了 { } ;
如果你想去除重复的元素,可以使用集合生成式。
四、字符串
1、字符串的分割
split()方法:指定分隔符对字符串进行切片
语法:strname.split(x)
- strname-- 字符串名
- x-- 指定的分隔符
2、字符串的替换
replace()方法:把字符串中的旧字符串替换成新字符串
语法:strname.replace(old, new)
- strname-- 字符串名
- old-- 将被替换的子字符串
- new-- 新字符串,用于替换old子字符串
3、字符串的合并
①、+ 方法
通过+这个符号来拼接字符串
②、join()方法:将列表(或元组)中多个字符串采用固定的分隔符连接在一起
语法:newstr = str.join(iterable)
- newstr-- 合并后生成的新字符串
- str-- 指定合并时的分隔符
- iterable-- 做合并操作的源字符串数据
lie = ['www', 'baidu', 'com']
newstr = '.'.join(lie)
print(newstr)
输出结果:
www.baidu.com
五、异常处理机制
try:
# 这部分写不能确定正确执行的代码
except Exception as e:
print('未知错误 %s' %e)
六、类和对象
1、定义类
定义类的基本语法如下:
class 类名:
多个(≥0)类属性...
多个(≥0)类方法...
2、类变量和实例变量
类体中、所有函数之外:此范围定义的变量,称为类属性或类变量;
类体中,所有函数之内:以“self.变量名”的方式定义的变量,称为实例属性或实例变量;
class Person():
introduce = "大家好!" # 类属性
def __init__(self, name, age):
self.name = name # 实例属性
self.age = age # 实例属性
3、实例方法、类方法和静态方法
不用任何修改的方法为实例方法;
采用 @classmethod 修饰的方法为类方法;
采用 @staticmethod 修饰的方法为静态方法。
class Person():
def say(self):
print("正在调用实例方法")
@classmethod
def eat(cls):
print("正在调用类方法")
@staticmethod
def drink():
print("正在调用静态方法")
4、类对象的创建和调用实例方法
class Person():
def say(self): # 实例方法
print("我是张三")
zhang = Person() # 创建类对象,zhang
"""
类对象调用实例方法的两种方式:
1、通过类对象名调用实例方法
2、通过类名直接调用实例方法
"""
zhang.say()
Person.say(zhang)
5、封装
如果类中的变量和函数,其名称以双下划线“__”开头,则该变量(函数)为私有变量(私有函数),从而实现类的封装。
参考:
https://blog.csdn.net/sinat_38682860/article/details/109560354
6、继承
实现继承的类称为子类,被继承的类称为父类(也可称为基类、超类)。
子类继承父类时,只需在定义子类时,将父类(可以是多个)放在子类之后的圆括号里即可。语法格式如下:
(具有多个父类,即为多继承)
class 类名(父类1, 父类2, ...):
#类定义部分
注意:如果该类没有显式指定继承自哪个类,则默认继承 object 类。
(object 类是 Python 中所有类的父类,即要么是直接父类,要么是间接父类)
class People:
def say(self):
print("我是一个人,名字是:",self.name)
class Animal:
def display(self):
print("人也是高级动物")
#同时继承 People 和 Animal 类
#其同时拥有 name 属性、say() 和 display() 方法
class Person(People, Animal):
pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
zhangsan.display()
有继承,就要有重写。重写指的是对类中已有方法的内部实现进行修改。
class Bird:
#鸟有翅膀
def isWing(self):
print("鸟有翅膀")
#鸟会飞
def fly(self):
print("鸟会飞")
class Ostrich(Bird):
# 重写Bird类的fly()方法
def fly(self):
print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
# 调用被重写的方法
ostrich.fly()
# 调用 Bird 类中的 fly() 方法 || 调用未被重写的方法
Bird.fly(ostrich)
在子类中的构造方法中,调用父类构造方法的方式:使用 super() 函数。但如果涉及多继承,该函数只能调用第一个直接父类的构造方法。
class People:
def __init__(self, name):
self.name = name
def say(self):
print("我是人,名字为:", self.name)
class Animal:
def __init__(self, food):
self.food = food
def display(self):
print("我是动物,我吃", self.food)
class Person(People, Animal):
# 自定义构造方法
def __init__(self, name, food):
# 调用 People 类的构造方法
super().__init__(name)
# super(Person,self).__init__(name) #执行效果和上一行相同
# People.__init__(self,name)#使用未绑定方法调用 People 类构造方法
# 调用其它父类的构造方法,需手动给 self 传值
Animal.__init__(self, food)
per = Person("zhangsan", "熟食")
per.say()
per.display()
7、多态
类的多态特性的前提条件:
- 继承:多态一定是发生在子类和父类之间;
- 重写:子类重写了父类的方法。
- 同一变量可能会被先后赋值不同的类对象。
class CLanguage:
def say(self):
print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
def say(self):
print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
def say(self):
print("调用的是 CLinux 类的say方法")
a = CLanguage()
a.say()
a = CPython()
a.say()
a = CLinux()
a.say()
Python 这种由多态衍生出的更灵活的编程机制,被称为“鸭子模型”或“鸭子类型”。例子如下:
class WhoSay:
def say(self,who):
who.say()
class CLanguage:
def say(self):
print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
def say(self):
print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
def say(self):
print("调用的是 CLinux 类的say方法")
a = WhoSay()
#调用 CLanguage 类的 say() 方法
a.say(CLanguage())
#调用 CPython 类的 say() 方法
a.say(CPython())
#调用 CLinux 类的 say() 方法
a.say(CLinux())
此程序中,通过给 WhoSay 类中的 say() 函数添加一个 who 参数,其内部利用传入的 who 调用 say() 方法。这意味着,当调用 WhoSay 类中的 say() 方法时,我们传给 who 参数的是哪个类的实例对象,它就会调用那个类中的 say() 方法。