python 不等于 False

文章目录

• python

• python入门

• 基本数据类型
• 变量赋值
• 数据类型间相互转换
• 组合数据类型

• 列表list
• 元组tuple
• 可变对象、不可变对象
• 字典dict
• 集合set

• 流程控制

• 条件判断

• 循环语句
• break、continue、pass

• 字符串进阶

• 字符串索引、切片
• 字符串常用函数

• count计数功能
• find查找功能
• index查找
• split字符串的拆分
• 字符串的替换
• 字符串标准化
• 字符串的变形
• 字符串的格式化输出
• format

• list进阶

• list常用函数

• 添加新的元素
• count计数和index查找
• 删除元素
• 列表生成式
• 生成器

• 函数

• 函数调用
• 参数传递

• 位置参数
• 缺省参数
• 可变参数
• 关键字参数
• 命名关键字参数
• 参数的组合

• 变量的作用域和global变量
• lambda匿名函数
• 高阶函数
• map/reduce
• sorted
• 装饰器

• 函数作为返回值
• 闭包
• 装饰器

• 偏函数
• 安装第三方模块

• python面向对象

• 类
• 类和对象
• 构造方法
• 魔术方法（内置方法）

• __str__字符串方法
• __lt__小于符号比较方法
• __le__小于等于比较符号方法
• __eq__比较运算符方法

• 封装
• 继承

• 单继承
• 多继承

• 复写和调用父类成员
• 变量的类型注解
• 函数和方法的类型的注解
• Union联合类型注解
• 多态

python

python入门

人生苦短，我用python
python的特点：简洁性、易读性、可扩展性

my_number=3200
guess_number=input("这台冰箱多少钱？")
guess_number=int(guess_number)
while guess_number!=my_number:
    if guess_number<my_number:
        guess_number=input("猜低了")
        guess_number=int(guess_number)
    else:
        guess_number=input("猜高了")
        guess_number=int(guess_number)

print("恭喜您，猜对了")

基本数据类型

整数、浮点数
**：幂运算、//：整除

round(0.1+0.2,2)

字符串是以单引号或双引号括起来的任意文本
布尔值只有True、False两种布尔值，布尔值可以用and、or和not运算

空值用None表示，None不能理解为0

变量赋值

python是一门动态语言

number=1
number**=2

number=5.5
number="world"

标识符：有字符、下划线和数字组成，第一个字符不能是数字
标识符中不能包含空格、@、%等特殊字符
标识符严格区分大小写

数据类型间相互转换

int(2.5)
str(4)
bool(3) #非0：true 0：false

组合数据类型

列表list

list是一种有序的集合，可以随时添加和删除其中的元素

list1=['physics',1994]
len(list1)
list1.append(4)
list1.pop() #弹出元素，list1中少一个元素

元组tuple

元组：有序列表，tuple一旦初始化就不能修改

tuple1=('physics',1997)

可变对象、不可变对象

可变对象：list、dict、set
不可变对象：tuple、string、int、float、bool

可变对象和不可变对象的区别：内存是否发生了变化

字典dict

字典使用（key-value）存储

word={'apple':'苹果','小张':100,4:'很好'}
word['小张']
word[4]
word['小赵']=80

集合set

set是一组key的集合，但不存储value，由于key不能重复，在set中没有重复的key

s={1,2,3,4}

流程控制

条件判断

score=80
if score>=60:
    print("及格")
else:
    print("不及格")

light='红灯'
if light=='红灯':
    print("停")
elif light=="绿灯":
    print("行")
else:
    print("等一等")

or、and、not

循环语句

# 从1数到9
number=1
while number<10:
    print(number)
    number+=1

for循环可以遍历任何序列的项目

for i in range(9):
    print(i+1)

fruits=['apple','banana']
for fruit in fruits:
    print(fruit)

break、continue、pass

使用break语句来完全终止循环
使用continent语句直接跳到循环的下一次迭代（continue：跳过本轮）

list1=[1,2,3,4,5,6]
for number in list1:
    if number==3:
        print("找到了")
        break

pass：占位，还没有想好怎么写，先让程序跑起来

字符串进阶

字符串索引、切片

切片：[起始:结束:步长]——>字符串[start : end : step]（左闭右开）

# 如果字符串以"pr"结尾，则打印
list_string=['apple','orange_pr']
for fruit in list_string:
    if fruit.endswith('pr'):
        print(fruit)

字符串常用函数

count计数功能

my_string='aabcabca'
my_string.count('abca') # 1

find查找功能

返回从左第一个指定字符的索引，找不到返回-1

index查找

返回从左第一个指定字符的索引，找不到报错

my_string="hello"
my_string.index('o')
my_string.find('o')

my_string.endswith('hello')
my_string.startswith('hello')

split字符串的拆分

my_string='hello_world'
my_string.split('_')

字符串的替换

从左到右替换指定的元素，可以指定替换的个数，默认全部替换

my_string="hello_word"
my_string.replace('_',' ')

字符串标准化

默认去除两边的空格、换行符之类的，去除内容可以指定

my_string=' hello_world\n'
my_string.strip()

字符串的变形

my_string="hello_world"
my_string.upper()
my_string.lower()
my_string.capitalize()

字符串的格式化输出

name="唐舞桐"
high=175
score_math=100
print('%s,%s,%s'%(name,high,score_math))

format

指定了:s，则只能传字符串，如果传其他类型值不会自动转换；当不指定类型时，传任何类型都能成功

name="唐舞桐"
high=175
score_math=100
print("{},{:d},{.2f}".format(name,high,score_math))

print("hello,{0},成绩提升了{1:.2f}".format("小明",6))

print("hello,{name},成绩提升了{score:.2f}".format(name="小明",score=6))

#  f-string
print(f"hello,{name},数学成绩：{score_math}")

list进阶

list常用函数

添加新的元素

list1=['a','b','c','d','e','f']
list1.append('g') #在列表末尾添加元素

list1.insert(2,'ooo') #在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加

list2=['x','y','z']
list1.extend(list2) #合并两个list，list2中仍有元素

count计数和index查找

list1=['a','b','a','d','a','f']
print(list1.count('a')) #3
print(list1.index('a')) #0
print('a' in list1) #true

删除元素

list1=['a','b','a','d','a','f']
print(list1.pop()) #f

print(list1.pop(4)) #a

list1.remove('a')
print(list1) #['b','a','d']

列表生成式

list1=[1,2,3,4,5]

for i in list1:
    list1[i]+=1

# 列表生成式
[n+1 for n in list1]
[(n+1)**2 for n in range(10)]

list1=['a','b','c','d','e','f']
[f'app_{n}' for n in list1]

list1=[1,2,3,4,5]
[n for n in list1 if n%2==0]

[m+n for m in 'abc' for n in 'xyz']

生成器

通过列表生成式，可以直接创建一个列表，但是受到内存限制，列表容量肯定是有限的

g=(x*x for x in range(10))
next(g)

for n in g:
    print(n)

def factor(max):
    factor_list=[]
    n=2
    while n<max:
        find=False
        for i in factor_list:
            if n%i==0:
                find=True
                break
        if not find:
            factor_list.append(n)
            yield n
        n=n+1

generator=factor(5)
for i in generator:
    print(i)

斐波那契数列

def fabonacci(max):
    n_1=1
    n_2=1
    n=0
    while n<max:
        if n==0 or n==1:
            yield 1
            n+=1
        else:
            yield n_1+n_2
            new_n_2=n_1
            n_1=n_1+n_2
            n_2=new_n_2
            n+=1

g=fabonacci(5)
for i in g:
    print(i)

函数

函数调用

def student(name):
    print(f"{name}")
    return {'姓名':name}

#返回多个值
def student_name_and_age():
    name='唐舞桐'
    age=18
    return name,age

ret=student_name_and_age()
type(ret) #tuple
name,age=student_name_and_age()

参数传递

位置参数

位置参数必须以正确的顺序传入函数，数量必须和声明时一样

缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值

def student(name,age='不愿意透露'):
    print(f"姓名：{name}，年龄：{age}")

student("唐舞桐")
student("唐舞桐",18)

可变参数

可变参数是传入的参数个数是可变的

def student(*names):
    print(type(names)) #tuple
    for name in names:
        print(name)

student("唐舞桐","霍雨浩","古月娜")
names=("唐舞桐","霍雨浩","古月娜")
student(names)

可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

关键字参数

关键字参数允许传入0个或任意个参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def student(name,age,**info):
    print(f'name:{name},age:{age},information:{info}')
    print(type(info)) #dict

student('唐舞桐',18,height=168)
# name:唐舞桐,age=18,information:{'height':168}

def student(name,age,**info):
    print(f"name:{name},age:{age},information:{info}")
    if 'city' in info:
        print(f"来自{info['city']}")

student('唐舞桐',18,height=168,city='上海')

score={‘chinese’:100,‘math’:98}
**score => chinese=100,math=98

命名关键字参数

如果限制关键字参数的名字，就可以使用命名关键字参数

def student(name,age,*,height,weight):
    print(f'name:{name},age:{age},height:{height},weight:{weight}')

student('唐舞桐',18,height=168,weight=90)

参数的组合

在python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

def student(name,age=18,*books,city,**kw):
    # 如果函数定义中已经有了一个可变参数，后面的命名关键字参数就不再需要一个特殊分隔符*了
    print(f"name:{name},age:{age},其他信息:{kw}")
    print(f"来自:{city}")
    for book in books:
        print(f"read {book}")
        
student("唐舞桐",18,"语文","数学","英语",city="上海",height=168,weight=90)

变量的作用域和global变量

局部变量作用域：在函数内
全局变量作用域：在函数外

函数优先使用局部变量，在没有局部变量的情况下，使用全局变量

name="唐舞桐"
def print_name():
    name='霍雨浩'
    print(name)

定义在函数内部的变量，函数结束之后自动消亡

def change_my_name():
    global name
    print(f"曾用名：{name}")
    name='唐舞桐'
    print(f"现在的名字：{name}")

name="霍雨浩"
change_my_name()

lambda匿名函数

lambda只是一个表达式，函数体比def简单
lambda的主体只是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数

# lambda 若干输入参数：返回值的表达式
add = lambda arg1,arg2:arg1+arg2 #add：函数名
add(1,2)

()表示函数调用

高阶函数

print()本身是一个内建函数

my_print=print
# 函数名其实就是指向函数的变量

函数的名字也可以作为一个变量，传入其他函数

def fun(x,f):
    return f(x)

fun(-1,abs)

高阶函数：一个函数可以接收另一个函数作为参数

int2str=lambda x:str(x)

map/reduce

map()函数接收两个参数，一个是函数，一个是iterable（可以用for遍历），map将传入的函数依次作用到序列的每个元素，并把结果作为iteration返回

ls=[1,2,3,4,5,6,7,8,9]
fx = lambda x:x**2
rst=map(fx,ls)
print(rst)

reduce()：用传给reduce中的函数function（有两个参数），先对集合中的第1、2个元素进行操作，得到的结果再与第三个数据用function函数运算，以此类推，最后得到一个结果

# 从python3开始，reduce函数移到了functools包
import functools
mul_xy=lambda x,y:x+y
functools.reduce(mul_xy,[1,2,3,4])

sorted

无论是冒泡排序还是快速排序，排序的核心是比较两个元素的大小

sorted([36,5,-12,9])
sorted([36,5,-12,9],reverse=True)
sorted([36,5,-12,9],key=abs)

f_x=lambda x:x[0]
point=[(5,2),(2,3),(4,1)]
sorted(point,key=f_x)

装饰器

小王同学本身是小王同学，有一天他带了一个围脖（装饰器），但是他还是小王同学

函数作为返回值

def calc(*args):
    def sum():
        ax=0
        for n in args:
            ax=ax+n
        return ax
    return sum

f=calc(1,3,5,7,9) # f是一个函数名
f() # f本身是一个包裹，这个包裹里面包含参数

闭包

闭包：如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）

def create_pointer(my_string):
    def pointer(n):
        return my_string[n]
    return pointer

pointer=create_pointer("唐舞桐")
pointer(0)

def count():
    fs=[]
    for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
    return fs

f1,f2,f3=count()
print(f1()) # 9
print(f2()) # 9
print(f3()) # 9

返回闭包时：返回函数不要引用任何循环变量，或者后续会发生变化的变量

装饰器

装饰器：用来装饰python的工具，是一种函数的函数，因为装饰器传入的参数就是一个函数，然后通过实现各种功能对这个函数的功能进行增强

def print_working(func):
    def wrapper():
        print(f"{func.__name__} is working")
        func()
    return wrapper

def work1():
    print("worker1")

work1=print_working(work1)
work1()

@print_working
def work1():
    print("worker1")

work1()

装饰器最大的优势是用于解决重复性的工作：计算函数的运行时间、给函数打日志

def arg_decorator(func):
    def wrapper(*args,**kw):
        print(f"{func.__name__} is working")
        func(*args,**kw)
    return wrapper

@arg_decorator
def student(name,age=18,*books,**kw):
    print(f"{name},{age}")
    for book in books:
        print(book)
    print(kw)

偏函数

通过设定参数的默认值，降低函数调用的难度

def student(name,age,city="北京"):
    print(f"{name},{age},{city}")

from functools import partial
student=partial(student,city="北京")
student("唐舞桐",18,"上海")

安装第三方模块

pip install/uninstall

python面向对象

类

设计类（class)
创建对象
对象属性赋值

class Student:
    name=None # 记录学生姓名

# 基于类创建对象
stu_1=Student()
stu_2=Student()

stu_1.name="唐舞桐"
stu_2.name="霍雨浩"

None是一个对象，None不等于0、任何空字符串、False
通过类创建对象，通过对象维护数据

类的使用语法：
        class 类名称:
            类的属性
            类的行为

类的属性，即定义在类中的变量（成员变量）
类的方法，即定义在类中的函数（成员方法）

创建类对象的语法：对象=类名称()

class Student():
    name=None
    age=None

    def say(self):
        print(f"{self.name}")

在类中定义成员方法和定义函数基本一致，但仍有细微区别：
    def 方法名(self,形参1,...,形参n):
        方法体

self关键字是成员方法定义的时候，必须填写的：
1、它用来表示类对象自身
2、当我们使用类对象调用方法时，self会自动被python传入
3、在方法内部，想要访问类的成员变量，必须使用self
在传入参数的时候，self是透明的，可以不用理会它

class Student:
    name=None

    def say(self):
        print("hello")

student=Student()
student.say()

类和对象

现实世界的事物有属性和行为，类也有属性和行为

面向对象编程：类只是一种程序内的“设计图纸”，需要基于图纸产生实体（对象），才能正常工作

设计类，基于类创建对象，由对象做具体的工作
面向对象编程：让对象干活

构造方法

构造方法：__init__()

在创建类对象（构造类）的时候，会自动执行；在创建类对象（构造类）的时候，将传入的参数自动传递给__init__方法使用

class Student:
    # 可以省略
    # name=None
    # age=None
    def __init__(self,name,age):
        # 声明变量并赋值
        # 变量是定义在构造方法的内部，如果要成为成员变量，需要用self表示
        self.name=name
        self.age=age

student = Student("唐舞桐",18)

构造方法也是成员方法，不要忘记在参数列表中提供：self
在构造方法内定义成员变量，需要使用self关键字

魔术方法（内置方法）

__str__字符串方法

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        print(f"name={self.name},age={self.age}")

student=Student("唐舞桐",18)
print(student) # name=唐舞桐,age=18
print(str(student)) # name=唐舞桐,age=18

__lt__小于符号比较方法

直接对两个对象进行比较是不可以的，但是在类中实现__it__方法，即可完成

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    # other：另一个类对象
    def __lt__(self, other):
        return self.age<other.age
    
student=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1<student1)

__le__小于等于比较符号方法

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    # other：另一个类对象
    def __le__(self, other):
        return self.age<=other.age

student=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1<student1)

__eq__比较运算符方法

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    # other：另一个类对象
    def __eq__(self, other):
        return self.age==other.age

student=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1==student1)

封装

面向对象编程：基于类去创建对象，使用对象完成功能开发

封装表示的是，将现实世界事物的属性、行为封装到类中，描述为成员变量、成员方法，从而完成程序对现实世界事物的描述
现实世界中的事物，有属性和行为，但是不代表这些属性和行为都是开放给用户使用的

私有成员变量：变量名以__开头
私有成员方法：方法名以__开头
私有方法无法直接被类对象使用
私有变量无法赋值，也无法取值

class Phone:
    __current_voltage=None
    
    def __keep_single_score(self):
        print("让CPU以单核模式运行以节省电量")

私有成员无法被类对象使用，但是可以被其他的成员使用

class Phone:
    __current_voltage=0.5
    def __keep_single_score(self):
        print("让CPU以单核模式运行")
    def call_by_5g(self):
        if self.__current_voltage>=1:
            print("5g通话已开启")
        else:
            self.__keep_single_score()
            print("电量不足，无法进行5g通话")

继承

单继承

class 类名(父类名):
    类内容体

class Phone:
    producer=None

    def call_by_4g(self):
        print("4g通话")

class Phone2022(Phone):
    face_id='10010'

    def call_by_5g(self):
        print("5g通话")

被继承的类叫父类，继承的类叫子类

多继承

python的类之间也支持多继承，即一个类可以继承多个父类

class 类名(父类1,父类2,...父类N)：
    类内容体

class Phone:
    producer=None

    def call_by_4g(self):
        print("4g通话")
        
class NFC:
    nfc_type="第五代"
    
    def read(self):
        print("读卡")

class Phone2022(Phone):
    face_id='10010'

    def call_by_5g(self):
        print("5g通话")

class MyPhone(Phone,NFC):
    pass

多继承注意事项：多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级
即：先继承的保留，后继承的被覆盖

复写和调用父类成员

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写
即：在子类中重新定义同名的属性或方法即可

class Phone:
    producer="ITCAST"
    def call_by_5g(self):
        print("父类的5g通话")

class MyPhone(Phone):
    producer = "hm"
    def call_by_5g(self):
        print("子类的5g通话")

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员
如果需要使用被复写的父类的成员：
1、调用父类成员：使用成员变量：父类名.成员变量；使用成员方法：父类名.成员方法(self)
2、使用super()调用父类成员：使用成员变量：super().成员变量；使用成员方法：super().成员方法()

class Phone:
    producer="ITCAST"
    def call_by_5g(self):
        print("父类的5g通话")

class MyPhone(Phone):
    producer = "hm"
    def call_by_5g(self):
        Phone.call_by_5g(self)
        super().call_by_5g()
        print("子类的5g通话")

变量的类型注解

pycharm无法通过代码确定应传入什么类型，我们需要使用类型注解
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显示地说明）
支持：变量的类型注解、函数（方法）形参列表和返回值的类型注解
为变量设置类型注解 基础语法：变量:类型

# 基础数据类型注解
var1:int = 10
var2:str = "唐舞桐"
var3:bool = True

# 类对象类型注解
class Student:
    pass

student:Student=Student()

# 基础容器类型注解
my_list:list=[1,2,3]
my_tuple:tuple=(1,2,3)
my_set:set={1,2,3}
my_dict:dict={"name":"唐舞桐"}

# 容器类型详细注解
my_list1:list[int]=[1,2,3]
my_tuple1:tuple[int,str,bool]=(1,"唐舞桐",True)
my_set1:set[int]={1,2,3}
my_dict1:dict[str,str]={"name":"唐舞桐"}

元组类型设置类型详细注解，需要将每一个元素都标记出来
字典类型设置类型详细注解，需要2个类型，第一个是key、第二个是value
在注释中进行类型注解，语法：#type:类型

import json
import random

var1 = random.randint(1, 10)  # type: int
var2 = json.loads('{"name":"唐舞桐"}') #type: dict[str,str]

alt+回车键：自动搜索module
类型注解仅仅是提示性的，不是决定性的

var1:int="唐舞桐"

函数和方法的类型的注解

函数和方法的形参类型注解语法：
def 函数方法名(形参名:类型,函数名:类型,...):
    pass

def add(x:int,y:int):
    return x+y
def func(data:list):
    pass

函数（方法）的返回值也是可以添加类型注解的

语法：def 函数方法名(形参:类型,...,形参:类型)->返回值类型:
        pass

def add(x:int,y:int)->int:
    return x+y

Union联合类型注解

使用Union[类型,…,类型]可以定义联合类型注解

from typing import Union

my_list:list[Union[str,int]]=[1,2,"唐舞桐","霍雨浩"]
my_dict:dict[str,Union[str,int]]={"name":"唐舞桐","age":18}

def func(data:Union[int,str])->Union[int,str]:
    pass

多态

多态：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态

class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("汪汪汪")
class Cat(Animal):
    def speak(self):
        print("喵喵喵")

def make_noise(animal:Animal):
    animal.speak()
dog=Dog()
cat=Cat()

make_noise(dog)
make_noise(cat)

同样的行为（函数），传入不同的对象，得到不同的状态
以父类做定义声明，以子类做实际工作，用以获得同一行为、不同状态

抽象类：含有抽象方法的类称为抽象类

抽象方法：方法体是空实现的（pass）称为抽象方法

抽象类就好比定义一个标准，包含了一些抽象的方法，要求子类必须实现

目前的知识点还缺少：文件操作、异常，将在近几天进行补充