python学习笔记（二）

一、python的判断

1.1 python的判断的语法

判断时从上到下运行，只要满足一个条件，就运行结果，后面的就不运行了，例如：

age = int(input('请输入您的年龄：'))
if age > 60:
    print('该退休了')
elif age > 30:
    print('社会的栋梁')
elif age > 20:
    print('年轻人')
else:
    print('加油，好好学习')

请输入您的年龄：21
年轻人

注意：input()获取的值是字符串类型，需要int()转成整数，整数之间才能作比较。

1.2 判断条件

判断条件	说明
==	等于
i=	不等于
>=	大于等于
<=	小于等于
in	判断是否在其中
is	判断类型
not in
not is

举例说明 in和is

a = input('请输入一个数字：')
if a in '0123456789':
    a=int(a)
else:
    print('请输入正确的数字！')
print('-------------------------')
b = 'asdff'
if type(b) is int:
    print('是整数')
elif type(b) is str:
    print('是字符串')
elif type(b) is bool:
    print('是布尔值')
else:
    print('不是整数、字符串、布尔值')

请输入一个数字：233
请输入正确的数字！
-------------------------
是字符串

二、python的循环

2.1 while循环

while循环基本语法

a = 1
while a < 10:
    print('hello',a)
    a = a + 2

hello 1
hello 3
hello 5
hello 7
hello 9

while结合之前的综合练习

小练习：
现在有10个学生的成绩，需要录入系统。
这是个人分别是：阿萨，猫咪，狗哥，海河，平安，大飞，六六，七七，小可，木棉。
并且名字和成绩需要对应上。
而且大于60的和小于60的需要分开存放。

"""
小练习
现在有10个学生的成绩，需要录入系统。
这是个人分别是：阿萨，猫咪，狗哥，海河，平安，大飞，六六，七七，小可，木棉
并且名字和成绩需要对应上。
而且大于60的和小于60的需要分开存放
"""
highscore = {}
lowscore  = {}
studentlist = ['阿萨','猫咪','狗哥','海河','平安','大飞','六六','七七','小可','木棉']
a = 0
while a < len(studentlist):
    score = int(input('请输入'+studentlist[a]+'的成绩：')) #注意用加号连接
    if score >= 60:
        highscore[studentlist[a]] = score
    else:
        lowscore[studentlist[a]] = score
    a = a + 1
print('大于60分同学的成绩:',highscore)
print('小于60分同学的成绩:',lowscore)

请输入阿萨的成绩：45
请输入猫咪的成绩：67
请输入狗哥的成绩：45
请输入海河的成绩：89
请输入平安的成绩：56
请输入大飞的成绩：78
请输入六六的成绩：34
请输入七七的成绩：76
请输入小可的成绩：53
请输入木棉的成绩：98
大于60分同学的成绩: {'猫咪': 67, '海河': 89, '大飞': 78, '七七': 76, '木棉': 98}
小于60分同学的成绩: {'阿萨': 45, '狗哥': 45, '平安': 56, '六六': 34, '小可': 53}

2.2 for循环

for循环通过遍历实现

for循环基本语法

a = ['阿萨','猫咪','狗哥','海河','平安','大飞','六六','七七','小可','木棉']
for i in a:
    print(i)

阿萨
猫咪
狗哥
海河
平安
大飞
六六
七七
小可
木棉

for结合之前的综合练习

小练习1：
现在有10个学生的成绩，需要录入系统。
这是个人分别是：阿萨，猫咪，狗哥，海河，平安，大飞，六六，七七，小可，木棉。
并且名字和成绩需要对应上。
而且大于60的和小于60的需要分开存放。

"""
小练习
现在有10个学生的成绩，需要录入系统。
这是个人分别是：阿萨，猫咪，狗哥，海河，平安，大飞，六六，七七，小可，木棉
并且名字和成绩需要对应上。
而且大于60的和小于60的需要分开存放
"""
highscore = {}
lowscore  = {}
studentlist = ['阿萨','猫咪','狗哥','海河','平安','大飞','六六','七七','小可','木棉']
for i in studentlist:
    score = int(input('请输入'+i+'的成绩：'))
    if score >= 60:
        highscore[i] = score
    else:
        lowscore[i] = score
print('大于60分同学的成绩:',highscore)
print('小于60分同学的成绩:',lowscore)

请输入阿萨的成绩：23
请输入猫咪的成绩：69
请输入狗哥的成绩：45
请输入海河的成绩：96
请输入平安的成绩：37
请输入大飞的成绩：90
请输入六六的成绩：47
请输入七七的成绩：61
请输入小可的成绩：56
请输入木棉的成绩：76
大于60分同学的成绩: {'猫咪': 69, '海河': 96, '大飞': 90, '七七': 61, '木棉': 76}
小于60分同学的成绩: {'阿萨': 23, '狗哥': 45, '平安': 37, '六六': 47, '小可': 56}

小练习2
实现九九乘法表

"""
练习
九九乘法表
"""
for i in range(1,10):
    for j in range(1,i+1):
        print(i,'x',j,'=',i*j,end='  ')
    print()

1 x 1 = 1  
2 x 1 = 2  2 x 2 = 4  
3 x 1 = 3  3 x 2 = 6  3 x 3 = 9  
4 x 1 = 4  4 x 2 = 8  4 x 3 = 12  4 x 4 = 16  
5 x 1 = 5  5 x 2 = 10  5 x 3 = 15  5 x 4 = 20  5 x 5 = 25  
6 x 1 = 6  6 x 2 = 12  6 x 3 = 18  6 x 4 = 24  6 x 5 = 30  6 x 6 = 36  
7 x 1 = 7  7 x 2 = 14  7 x 3 = 21  7 x 4 = 28  7 x 5 = 35  7 x 6 = 42  7 x 7 = 49  
8 x 1 = 8  8 x 2 = 16  8 x 3 = 24  8 x 4 = 32  8 x 5 = 40  8 x 6 = 48  8 x 7 = 56  8 x 8 = 64  
9 x 1 = 9  9 x 2 = 18  9 x 3 = 27  9 x 4 = 36  9 x 5 = 45  9 x 6 = 54  9 x 7 = 63  9 x 8 = 72  9 x 9 = 81  

小练习3
通过print打印，模拟一个红绿灯的功能，注意：红灯8次，绿灯10次，黄灯2次

"""
练习：
通过print打印，模拟一个红绿灯的功能，注意：红灯8次，绿灯10次，黄灯2次
"""
light = {'红灯':8,'绿灯':10,'黄灯':2}
for i in light:
    for j in range(0,light[i]):
        print(i,'倒计时还有',light[i]-j,'秒')

红灯 倒计时还有 8 秒
红灯 倒计时还有 7 秒
红灯 倒计时还有 6 秒
红灯 倒计时还有 5 秒
红灯 倒计时还有 4 秒
红灯 倒计时还有 3 秒
红灯 倒计时还有 2 秒
红灯 倒计时还有 1 秒
绿灯 倒计时还有 10 秒
绿灯 倒计时还有 9 秒
绿灯 倒计时还有 8 秒
绿灯 倒计时还有 7 秒
绿灯 倒计时还有 6 秒
绿灯 倒计时还有 5 秒
绿灯 倒计时还有 4 秒
绿灯 倒计时还有 3 秒
绿灯 倒计时还有 2 秒
绿灯 倒计时还有 1 秒
黄灯 倒计时还有 2 秒
黄灯 倒计时还有 1 秒

2.3 跳出或终止循环

方法	说明
continue	跳过本次循环
break	跳出循环/终止循环

for i in range(0,5):
    if i == 2:
        continue
    print(i)
print('-------------------')
for j in range(0,5):
    if j == 2:
        break
    print(j)

0
1
3
4
-------------------
0
1

三、方法（函数）的定义

3.1 格式与举例

1、定义一个方法需要有： 方法的声明，方法的名字，方法的参数（可以没有），方法的逻辑代码
2、方法的参数的定义主要有四种情况：
（1）def functionname(arg1,arg2,…)
在这种调用方法中，形参和实参的个数必须一致，而且必须一一对应，也就是说第一个形参对应着第一个实参。
（2）def functionname(arg1,arg2=value2,…)
这种方式就是第一种的改进版，提供了默认值.
（3）def functionname(*arg1)
上面两种方式是有多少个形参，就传进去多少个实参，但有时候会不确定有多少个参数，则此时第三种方式就比较有用，它以一个加上形参名的方式来表示这个函数的实参个数不定，可能为0个也可能为n个。注意一点是，不管有多少个，在函数内部都被存放在以形参名为标识符的元组中。
（4）def functionname（**arg1)
形参名前加两个表示，参数在函数内部将被存放在以形式名为标识符的字典中，这时调用函数的方法则需要采用arg1=value1,arg2=value2这样的形式。

3、方法的说明一般放在def下面，如下所示。这么放，在使用它时可以看见方法的说明

def checkname(username):
    """
    自动判断账号长度是5-8位，并且账号必须小写开头
    """
    if len(username) >=5 and len(username) <=8:
        if username[0] in 'qwertyuiopasdfghjklzxcvbnm':
            print('OK')
        else:
            print('账号的首字母必须是小写字母')
    else:
        print('账号的长度不符合规范，请输入5-8位的账号')
#def 方法的声明
#checkname 方法的名字
#username 方法的参数
#方法的逻辑代码
a = '8qqwww'
checkname(a)

账号的首字母必须是小写字母

3.2 方法的返回值

3.1中举例的方法checkname()是没有返回值的，设置返回值，可以直接将print()改成return
设不设置方法的返回值的区别，用以下例子说明：

不设置返回值

def sum(a,b):
    """
    实现两个数的相加
    """
    if type(a) is int and type(b) is int:
        print(a+b)
    else:
        print('请输入整数')

a = 2
b = 4
print(sum(a,b))

None

设置返回值

def sum(a,b):
    """
    实现两个数的相加
    """
    if type(a) is int and type(b) is int:
        return a+b
    else:
        return '请输入整数'

a = 2
b = 4
print(sum(a,b))

6

说明：返回值，返回后我们可以对这个值做其他操作
而print()不能

四、异常捕获

作用：
1.控制用户输入的数据
代码举例如下：

try:
    print('a'+kjf)
except Exception as e:
    print('上面的代码有错',e)

上面的代码有错 name 'kjf' is not defined

五、python 里的单位

python 里的单位（从大到小）：包->模块->类->方法->变量，它们的关系既包含又并列。

5.1 包与模块

1.python的包分为自带的和第三方的
2.python的包在Lib文件夹里，里面.py的文件是模块
3.导入方法例如：import numpy
4.安装第三方包的方法例如：conda install numpy
5.所有的.py文件都是一个模块

5.2 类

注意：
1.类名首字母必须大写
2.默认属性方法__init__
3.使用__init__来接受参数
4.每个类里面的方法，第一个参数必须是self
5.在定义类的时候一定要写self，在外面使用类时不用写了

例如：

class Friend():
    """
    定义一个朋友的类
    """
    def __init__(self,name,high,age):
        self.name = name
        self.high = high
        self.age = age

    def speciality(self,num):
        """
        特长
        """
        print(self.name ,'likes',end=' ')
        if num == 1:
            print('singing')
        elif num == 2:
            print('swimming')
        else:
            print('dancing')
    def  work(self,num):
        """
        职业
        """
        print(self.name, 'is a',end=' ')
        if num == 1:
            print('teacher')
        else:
            print('doctor')
#类的实例化
friend = Friend('Your friend','172cm',21)
friend.speciality(1)
friend.work(3)
print(friend.high)

Your friend likes singing
Your friend is a doctor
172cm

类的两个特点：
1.继承
2.重写
代码举例：

class Person(Friend):
    """
    Person()类继承于Friend()类
    继承了里面的参数
    重写了Friend()类里的方法work()
    """
    def work(self,num):
        """
         职业
        """
        print(self.name, 'is a', end=' ')
        if num == 1:
            print('policemen')
        else:
            print('engineer')
#类的实例化
person = Person('Amy','170cm','22岁')
person.work(1)

Amy is a policemen

对于所有的类，都有一组特殊的属性

类属性	含义
__name__	类的名字（字符串）
__doc__	类的文档字符串
__bases__	类的所有父类组成的元组
__dict__	类的属性组成的字典
__module__	类所属的模块
__class__	类对象的类型

代码举例：

class Money:
    pass
one = Money()#实例化，将类的唯一标识赋值给变量

print(Money.__name__)
print(Money.__doc__)
print(Money.__bases__)
print(Money.__dict__)
print(Money.__module__)
print(Money.__class__)
print(one.__class__)

Money
None
(<class 'object'>,)
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Money' objects>, '__weakref__': <attribute '__weakref__' of 'Money' objects>, '__doc__': None}
__main__
<class 'type'>
<class '__main__.Money'>

PS：属性分为类属性和实例属性

5.3 对象

Python中一切皆对象，Python对象分为两种，可变对象和不可变对象。可变对象可以修改，不可变对象无法更改。每个对象至少包含三个数据：类型、值和计数。
不可变对象：int(整形)、str(字符串)、float(浮点型)、tuple(元组)
可变对象：dict(字典)、list(列表)、set(集合)
接上部分举例：

one.age = 18
print(one.__doc__)
print(one.__dict__)
print(one.__module__)
print(id(one.age))

one.age += 1
print(id(one.age))

one.age -= 1
print(id(one.age))

None
{'age': 18}
__main__
1939387104
1939387136
1939387104

one.age += 1是新建了一个id，里面放了一个新值，one.age指向了新id。所以int(整形)是
不可变对象。

5.4 方法

Python方法可以分为三类：实例方法(默认第一个参数需要接收到一个实例)、类方法（默认第一个参数需要接收到一个类）和静态方法（第一个参数啥也 不默认接受）
1.划分的依据是：方法的第一个参数必须要接受的数据类型；
2.不管是哪一种类型的方法，都储存在类当中；没有在实例当中的；
3.不同类型方法的调用方式不同。

class Person:
    def shilifangfa(self):
        print("这是一个实例方法", self)

    @classmethod
    def leifangfa(cls):
        print("这是一个类方法", cls)

    @staticmethod
    def jingtaifangfa():
        print("这是一个静态方法")


amy = Person()
print(amy.__dict__)
print(Person.__dict__)

{}
{'__module__': '__main__', 'shilifangfa': <function Person.shilifangfa at 0x00000258B02A88C8>, 'leifangfa': <classmethod object at 0x00000258B010D518>, 'jingtaifangfa': <staticmethod object at 0x00000258B010D4A8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

5.4.1实例方法

class Person:
    def eat(self, food):
        print("在吃", food, self)
print(Person)

p = Person()
print(p)
p.eat("土豆")

p1 = Person()
print(p1)
p1.eat("西红柿")

<class '__main__.Person'>
<__main__.Person object at 0x000001F15A5B2048>
在吃 土豆 <__main__.Person object at 0x000001F15A5B2048>
<__main__.Person object at 0x000001F15A5ABFD0>
在吃 西红柿 <__main__.Person object at 0x000001F15A5ABFD0>

self就是Person类的实例本身，p是Person类的实例，两者打印出来地址一致。

5.4.2类方法

类方法可以被类调用，也可以被实例调用。

class Person:
    # def eat(self, food):
    #     print("在吃", food, self)
    @classmethod
    def leifangfa(cls, a):
        print("这是一个类方法", cls, a)
#类调用
Person.leifangfa(123)
#实例调用
p = Person()
p.leifangfa(666)

#衍生类
class A(Person):
    pass
A.leifangfa(000)

这是一个类方法 <class '__main__.Person'> 123
这是一个类方法 <class '__main__.Person'> 666
这是一个类方法 <class '__main__.A'> 0

5.4.3静态方法

静态方法可以被类调用，也可以被实例调用。

class Person:
    @staticmethod
    def jingtai():
        print("这是一个静态方法")

#类调用
Person.jingtai()
#实例调用
p = Person()
p.jingtai()

这是一个静态方法
这是一个静态方法

5.4.4三种方法访问类属性和实例属性的权限问题

1、实例方法可访问类属性和实例属性
2、类方法可访问类属性,无法访问实例属性

class Person:
    age = 28
    def shilifangfa(self):
        print(self)
        print(self.age)
        print(self.num)
    @classmethod
    def leifangfa(cls):
        print(cls)
        print(cls.age)
    @staticmethod
    def jingtaifangfa():


p = Person()
p.num = 10

#实例方法可访问类属性和实例属性
p.shilifangfa()

#类方法可访问类属性,无法访问实例属性
p.leifangfa()

<__main__.Person object at 0x0000011A7423B358>
28
10
<class '__main__.Person'>
28

六、文件的读写

制表符	说明
\t	增加一个table的位置
\n	换行

文件的读写举例：

#文件的读写
text = input('请输入今天的心情：')
with open("日记.txt","a",encoding="utf8") as f:
    f.write(text)

with open("日记.txt","r",encoding="utf8") as f:
    text = f.readlines()
    print(text)

请输入今天的心情：现在晚上10点了，我想睡觉了
['现在晚上10点了，我想睡觉了']

总结

python的语法
1.python是用缩进4格，来区分代码块
2.方法的说明一般放在def下面
3.不设置返回值，返回的是None
等等

不定期更新，若有错误，欢迎指教！！！