python基础知识（复习）

数据类型

基本知识

#格式化输出
print('{}，{}'.format("你好",18))
name = "yom"
print('欢迎%s' %name)
print("hello %s,你在%s"%(name,'伤感'))
print('{1} {0}'.format('x','y'))
print('{name}{age}'.format(name=name,age=19))
print(f'9乘以3等于{9*3}')
# 运算符
# 算术运算符：+-*/ // %  **
print(3**3)
# 比较运算符 赋值运算符 逻辑运算符：not 取反 or取或 and取是
#优先级：（）> not > and >or
print(not 5>10) #True
print(0) #0为false，其他为true

print(not '')
print(not None)# 空与None为false,其他为True

#先判断第一个值
print(1 or 9) #1    第一个值为true，返回第一个值，否则返回第二个
print(1 and 0) # 0   第一个值为true，第二个值也为true ，返回第二个值；任意一个值为false，直接返回false那个值；只要有0，返回0

#成员运算符 in               /       not in

#身份运算符 is      not is
x =y =10
print(x is y)  #true
print(x is not y) #false

#is 与 ==  : is 反映变量内存地址，地址不同，id不同 ==：反映值是否相同
#id不同的情况下，值有可能相同，即两块不同的内存空间里可以存相同的值
#id相同，值一定相同，即 x is y成立，x==y必然成立
x =('dd' ,'ddd')
y = ('dd','ddd')
print(x is y) #true 元组不可变
print(x == y) #true
x1=[1,2,3]
y1=[1,2,3]
print(x1 is y1) #false列表可变
print(x1 == y1) #true

#十进制转其他数据类型： 二：bin(3) 八：oct(3) 十六：hex(3)
#其他转十进制： 二：int('On11',2)  八： int('Oo3',8)/int('O03',8)  十六：int('Ox3',16)
#type()查看数据类型

字符串

#字符串详解
name = 'dsj'
print(id(name[0]))

str1='hello'
str2='world'
str3='helloworld'
str4=str1+str2
print(str3 is str4) #False 拼接会生成新的内存块
print(str3==str4)  #True

#反向切片
print(str1[::-1]) #olleh
print('he' in str1) #True
#常用函数
print(len(str1)) #长度查询
#性质判断（返回布尔值）
print(str1.startswith('he')) #判断字符开头
print(str1.endswith('lo')) #判断字符结尾
print(str1.isdigit()) #检查是否由数字构成
print(str1.isalpha()) #检查是否由字母构成
print(str1.isalnum) #检查是否由数字和字母构成

#格式化字符串
print(str1.center(11,'*'))
print(str1.rjust(20))
print(str1.ljust(20,'-'))
print('33'.zfill(20))

#修剪操作
str='2ffg'
str1 = 'lfdldfl'
str3=' ff '
print(str3.strip()) #去两边空格
print(str.strip('2'))
print(str1.lstrip('l'))
print(str1.rstrip('l'))

#替换操作
str.replace('f','gg')
# print(str)
print(str.replace('f','gg'))
print(str.replace('f','gg',1))
#拆分/合并
print(str1.split('d'))
print(str1.split('d',1))
print('#'.join(str))
str = "-"
seq = ("a", "b", "c") # 字符串序列
print(str.join(seq)) #以列表形式返回

s1='sdswdfsfwww'
print(s1.capitalize())
print(s1.find('www')) #8
print(s1.find('s',1))
print(s1.index('www')) #8
s2='hello world'
print(s2.title())
#解码、编码
# a.encode('utf-8')
# print(a)
#
# a.decode('utf-8')
# print(a)

列表

#列表详解
ls = list() #创建空列表
names=['tom','jack','jym']
print(names[0]) #按索引取值
print(names[0:2]) #切片
print('tom' in names) #成员运算in  / not in
print(len(names))

#追加 append
#追加一个元素
names.append('jim')
print(names)
#追加列表
names2 = ['dd','uu']
names.append(names2)
print(names) #['tom', 'jack', 'jym', 'jim', ['dd', 'uu']] 会以列表形式存在
#追加元组
names3 = ('fd','ue')
names.append(names3)
print(names) # ['tom', 'jack', 'jym', 'jim', ['dd', 'uu'], ('fd', 'ue')] 会以元组形式存在
#追加字典
names4 = {'ded':'defef'}
names.append(names4)
print(names) #['tom', 'jack', 'jym', 'jim', ['dd', 'uu'], ('fd', 'ue'), {'ded': 'defef'}]会以字典形式存在
#追加集合
names5 = {'你好','d嘿嘿'}
names.append(names5)
print(names) #['tom', 'jack', 'jym', 'jim', ['dd', 'uu'], ('fd', 'ue'), {'ded': 'defef'}, {'你好', 'd嘿嘿'}]会以集合形式存在

#合并 extend

books =['dsd','fsf']
books.extend('ee')
print(books) #['dsd', 'fsf', 'e', 'e'] 合并，不能单传一个元素，会被拆了
book1 = ['dw2','re3']
books.extend(book1)
print(books) #['dsd', 'fsf', 'e', 'e', 'dw2', 're3'] 合并进去，就是合并，不会以列表形式了
#列表里，合并元组 就变成列表了
book2 =('de11','e2ns')
books.extend(book2) #['dsd', 'fsf', 'e', 'e', 'dw2', 're3', 'de11', 'e2ns']
print(books)
#列表里，合并字典，只是合并了key
book3 = {'dwd':'dw32'}
books.extend(book3)
print(books) #['dsd', 'fsf', 'e', 'e', 'dw2', 're3', 'de11', 'e2ns', 'dwd']
#列表里，合并集合
book4 = {'哇哇d','d是的2'}
books.extend(book4)
print(books) #['dsd', 'fsf', 'e', 'e', 'dw2', 're3', 'de11', 'e2ns', 'dwd', 'd是的2', '哇哇d']

#插入insert 第一个表明插入的位置，第二个表面插入的元素
#如果插入元组、列表之类的也是当作一个元素,就是会以列表、元组形式存在
book1.insert(1,"c++")
print(book1)
ff = ['df','python']
book1.insert(1,ff)
print(book1)

# 删除操作 del
del book1[0]
print(book1)
del book4
#删除元素 pop 根据索引来输出，返回删除的那个元素
print(book1.pop(0))
print("---",book1)
#删除元素 remove 根据值来删除 ，不存在会报错
book1.remove('c++')
print(book1)
book1.clear()
print(book1)
#查找
print(book2.index('de11'))
print(book1.count('dw2'))

字典

#字典：和列表的区别;列表是有序的对象集合，字典是无序的对象集合，字典用{}定义，键必须是唯一的
dogs = {'name':'tom' , 'age': 19 }
print(dogs.keys())
for i in dogs.keys(): #返回所有key
    print(i)
for i in dogs.values(): #返回所有value
    print(i)
for i,v in dogs.items(): #返回所有（key,value)元组列表
    print(i,v)
print('---')
dogs1 = {'moth':'yy' , 'age': 12}
dogs2 = {'fath':'jack' , 'age': 22}
dogs.update(dogs1)
dogs.update(dogs2)
del dogs['name']
print(dogs.pop('fath'))

dogs.popitem() #随机删除一个键值对


dogs.setdefault('fath')
# dogs['fath']='kk'
print(dogs['fath'])

dogs.clear()
print(dogs)

集合

#集合：无序性、互异性、确定性
#集合中元素必须是hashable类型，即不可变类型，集合本身是可变类型，不能作为集合中元素
a = [1,2,2,3,4,3]    # 或者元组
a_result = list(set(a))
print(a_result)
a = a_result.copy()
print(a)

x = {3,2,1}
x.add(123)		#如果添加重复的会忽略，不会添加

if 444 in x :
	x.remove(123)
else:
	print('bcz')
if x.__contains__(444):	  #判断集合x中是否含有元素444
	x.remove(123)	#如果删除元素不存在就会抛出异常
else:
	print('444在集合中不存在')

x1 = {1,2,3}
x2 = {3,4,5}
print(x1 | x2)   #集合之间的合并   或者：print(x1.union(x2))

print(x1 & x2)   #相交      		  或者print(x1.intersection(x2))

print(x1 - x2)
print(x1.difference(x2))     # 输出为：{1,2}
#将x1有的，x2中也有的删除，返回的是x1的子集
print(x2 - x1)
print(x2.difference(x1))    # 输出为： {4, 5}
#将x2有的，x1中也有的删除，返回的是x2的子集
print(x1 ^ x2)      		 # 输出为：{1,2,4,5}
#刨除x1和x2共有的元素，返回的是集合并的子集

面向对象

class A:
    #类属性
    count = 0
    instance = None #用来记录当前创建的类对象的引用地址
    init_flag = False #用于记录init初始化方法的执行次数

    #实现单例
    def __new__(cls, *args, **kwargs):
        print("创建对象，分配空间")
        #判断属性是否为None,如果是第一次执行当前这个类，那么类属性就是一开始的None
        if cls.instance is None:
            #调用父类方法，类对象创建一个内存空间
            cls.instance = super().__new__(cls)
        # 返回类属性保存的对象引用
        return cls.instance



    def __init__(self,name,age,email):
        #判断init是否第一次执行
        if A.init_flag:
            return #不是第一次执行，则执行结束
        #是第一次执行时初始化：
        print("初始化---")

        self.__name = name
        self.__age = age
        self.email = email
        A.count = 1

        #执行一次初始化方法后，需要修改类属性中的值
        A.init_flag = True


    @classmethod
    def is_clsmethod(cls,a,b):
        A.is_shilimethod()
        print('调用类方法：第一参数必须是cls,表示当前方法属于当前类,是这个实例对象的引用')

    @staticmethod
    def is_stcmethod(a,b):
        print('调用静态方法：传入的参数都是普通参数，不需要进行实例化，可以直接使用类名.方法')

    @property #获取私有属性
    def name(self):
        print("偷看是吧")
        return self.__name

    # @*.setter装饰器必须在 @ property装饰器的后面，且两个被修饰的函数的名称必须保持一致，*即为函数名称
    @name.setter #修改私有属性
    def name(self,name1):
        print("这次就让你改了")
        self.__name = name1 or "默认"

    #实例方法
    def is_shilimethod(self):
        print("调用实例方法：传入的第一个参数是self,在类外时：实例方法不可以通过类进行调用（实例属性也是）。")

    def __repr__(self):  #打印对象
        return f'{self.email} {self.__name}'

#类实例化
a = A('zs',12,'33@qq.com')
# 创建对象，分配空间
# 初始化---
print(a.__repr__()) #33@qq.com zs

# 实例方法不可以通过类进行调用（实例属性也是）
# A.is_shilimethod() #TypeError: is_shilimethod() missing 1 required positional argument: 'self'
# A.email

#调用静态方法
A.is_stcmethod(1,2) #调用静态方法：传入的参数都是普通参数，不需要进行实例化，可以直接使用类名.方法

#修改、访问私有属性
a.name = 'jack' #这次就让你改了
print(a.name)
# 偷看是吧
# jack

#添加实例属性
a.school = '地球'
print(a.school) #地球
#添加类属性
A.school ='火星'
print(A.school) #火星

#获取类的调用顺序
print(A.__mro__) #(<class '__main__.A'>, <class 'object'>)