Python简单的入门基础内容

---

前言

内容为整理的学习笔记，不是原创，如有侵权请联系我删除。

---

class1：基本数据类型

基本数据类型：

integer
整型（整数类型）
1
5
100

float
浮点型（小数）
0.1
3.1415
189.153

string
字符串型
“This is a string”
“123”
‘123’

class2：基本的运算符

【+ 加】
【 - 减】
【* 乘】
【**平方】
【/ 除】
【 % 取余】
【// 取整】

class3：while循环和for循环

condition = 1

while condition < 5: #注意这里有一个分号
    print(condition)
    condition += 1

运行结果：
1
2
3
4

---

for i in range(5):
    print(i)

运行结果：
0
1
2
3
4

---

for i in range(2,10): #注意这里左边是闭区间右边是开区间
    print(i)

运行结果：
2
3
4
5
6
7
8
9

---

for i in range(1,10,2): # 这里从一开始，后面每个数加2
    print(i)

运行结果：
1
3
5
7
9

---

for i in [1,3,5,7]:
    print(i)
    
print('——————')

for i in (1,2,3,4):
    print(i)

运行结果：

1
3
5
7
————
1
2
3
4

class4：列表基础

a_list = [1,2,30,30,30,4,2] #列表
print(a_list)#打印列表中的所有元素

print("————")

print(a_list[1]) #打印列表的第一个元素
print(a_list[5])  #打印列表中第5个元素
print(a_list[-2]) #打印列表中倒数第2个元素

print("————")

print(a_list[1:4]) #打印列表中第1到第4个元素
print(a_list[:-2])#从头打印列表直到倒数第2个元素
print(a_list[-3:])#打印列表后三个元素

print("————")

for content in a_list:
    print(content)
    
print("————")

len(a_list)
print(a_list.index(30))#打印元素30第一次出现的位置

print("————")

a_list.sort()#给列表进行排序
print(a_list)

a_list.sort(reverse=True)#给列表进行反向排序
print(a_list)

运行结果：
[1, 2, 30, 30, 30, 4, 2]
————
2
4
4
————
[2, 30, 30]
[1, 2, 30, 30, 30]
[30, 4, 2]
————
1
2
30
30
30
4
2
————
2
————
[1, 2, 2, 4, 30, 30, 30]
[30, 30, 30, 4, 2, 2, 1]

class5：列表操作，多维列表

a_list = [1,2,30,30,30,4,2]
print(a_list)

print("————")

a_list[0] = 100 #修改列表中第0个元素
print(a_list) 

print("————")

a_list.append(200) #在列表末尾添加一个元素
print(a_list)

print("————")

a_list.insert(2,300) #在列表中插入一个元素
print(a_list)

print("————")

del a_list[2] #删除列表第2个元素
print(a_list)

print("————")

a_list.remove(30) #删除列表中的一个‘30’
print(a_list)

print("————")

a = a_list.pop()#pop把列表中最后一个值给弹出存入a中，然后列表中就没有这个元素了
print(a)
print(a_list)

print("————")

b_list = [[1,2,3],
          [4,5,6],
          [7,8,9]]
print(b_list[1])

print(b_list[2][1])

运行结果：
[1, 2, 30, 30, 30, 4, 2]
————
[100, 2, 30, 30, 30, 4, 2]
————
[100, 2, 30, 30, 30, 4, 2, 200]
————
[100, 2, 300, 30, 30, 30, 4, 2, 200]
————
[100, 2, 30, 30, 30, 4, 2, 200]
————
[100, 2, 30, 30, 4, 2, 200]
————
200
[100, 2, 30, 30, 4, 2]
————
[4, 5, 6]
8

class6：元组

a_tuple = (1,2,30,30,4,5)
b_tuple = 1,2,30,30,4,5
print(a_tuple)
print(b_tuple)

print("————")

print(a_tuple[1])

print("————")

print(a_tuple[1:4])

print("————")

print(a_tuple.count(30))#打印出30在元组中的个数

print("————")

for i in a_tuple:
    print(i)

print("————")   
    
    
 # a_tuple.sort()  #元组是不可以修改和排序的
# print(a_tuple)   
# a_tuple.append(200)

print("————")

a_tuple = (1,2,3,4)#元组只能重新的赋值
print(a_tuple)

运行结果：
(1, 2, 30, 30, 4, 5)
(1, 2, 30, 30, 4, 5)
————
2
————
(2, 30, 30)
————
2
————
1
2
30
30
4
5
————
————
(1, 2, 3, 4)

class7：if条件

'''
>   大于
>=  大于等于
<   小于
<=  小于等于
==  等于
!=  不等于
'''

'''
and  并且
or   或者
'''

a = 1
b = 2
c = 3
d = 1

if a<b and a==d:
    print("right")
    
print("————")

colors = ['red','blue','black','green']

for color in colors:
    if color == 'black':
        print('black')
    else:
        print('not black')

运行结果：
right
————
not black
not black
black
not black

class8：字典

d = {'pen':7,'apple':3,'applepen':10} #Key:Value,键：值
d2 = {1:'a',5:'b',2:'d'} #键 值的顺序是随意的
d3 = {1.2:3,'a':3.5,1:'aaa'}

print(d)#打印出来的顺序和你输入的顺序是不一样的，因为这个顺序是不重要的因为他是键值一对一的
print(d2)
print(d3)

print(d['apple'])
print(d2[2])
print(d3[1.2])

print("————")

d['pen'] = 10 #修改Key对应的Value
print(d)

print("————")

d['pineapple'] = 3 #新增一个key：value对，字典是没有顺序的容器
print(d)

print("————")

del d['pineapple'] #删除一个键值对
print(d)

运行结果：
{‘pen’: 7, ‘apple’: 3, ‘applepen’: 10}
{1: ‘a’, 5: ‘b’, 2: ‘d’}
{1.2: 3, ‘a’: 3.5, 1: ‘aaa’}
3
d
3
————
{‘pen’: 10, ‘apple’: 3, ‘applepen’: 10}
————
{‘pen’: 10, ‘apple’: 3, ‘applepen’: 10, ‘pineapple’: 3}

---

d4 = {'a':[1,2,3,4],'b':(1,2,3,4),'c':{'aa':1,'bb':2}}
print(d4)

#想要打印字典中的字典怎么操作呢
print(d4['c']['aa'])

运行结果：
{‘a’: [1, 2, 3, 4], ‘b’: (1, 2, 3, 4), ‘c’: {‘aa’: 1, ‘bb’: 2}}
1

---

d = {'pen':7,'apple':3,'applepen':10} #Key:Value,键：值
d2 = {1:'a',5:'b',2:'d'} #键 值的顺序是随意的

for key,value in d.items():#遍历整个字典的键值对
    print('key:',key,'\t','value:',value)
    
print("————")    
    
for key in d.keys():  #遍历整个字典的键
    print('key:',key)
    
print("————")    
    
for value in d.values(): #遍历整个字典的值
    print('values:',value)
    
print("————")    
    
for key in sorted(d.keys()):
    print('key:',key)
    
print("————")

for key in sorted(d2.keys()):
    print('key:',key)

运行结果：
key: pen value: 7
key: apple value: 3
key: applepen value: 10
————
key: pen
key: apple
key: applepen
————
values: 7
values: 3
values: 10
————
key: apple
key: applepen
key: pen
————
key: 1
key: 2
key: 5

class9：函数

def function(): #定义一个函数
    a = 1
    b = 2
    c = a + b
    print(c)
    
function()#调用这个函数

运行结果：
3

---

def function2(a,b): #定义一个带参数的函数，a，b为形参(局部变量)，只有在函数的内部发生作用
    c = a + b
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('a+b=',c)
    
function2(10,20)#调用这个函数

print("————")

a2 = 30
b2 = 40
function2(a2,b2)#调用这个函数

运行结果：
a= 10
b= 20
c= 30
a+b= 30
————
a= 30
b= 40
c= 70
a+b= 70

---

a = 100
b = 200

def function5(b=20): #设置默认值
    global a   #使用全局变量
    c = a + b
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('a+b=',c)
    
function5()

---

运行结果：
a= 100
b= 20
c= 120
a+b= 120

class10：模块

'''
有很多现成的模块如果导入直接导入就好了

如果想导入自己写好的模块，需要自己写的模块在当下文件的同一个目录下面

下面以自己写的模块为例

模块文件为max保存为python文件，也就是后缀名是.ipynb

文件内容是

def func_max(a,b):
    if a>b:
        return a
    else:
        return b
'''

#第一种导入模块的方法，这种方法在下面的应用中都需要带上模块名
import max #导入了max模块

a = max.func_max(10,20) #调用max模块中的func_max函数
print(a)

#第二种导入模块的方法

from max import func_max #从max模块中导入func_max函数

a = func_max(11,22)#这种导入就不需要在前面加上模块的名字了
print(a)


from max import * #导入max模块中所有的内容

import max as m #导入max，用as指定max的别名为m

a = m.func_max(22,44)
print(a)

class 11：类

class human:  #类
    def __init__(self,name='someone',age=10):#创建对象时会执行
        self.name = name
        self.age = age
        print('human init')
        
    #类的方法
    def my_name(self):
        print('my name is',self.name)
    def my_age(self):
        print('my age is',self.age)
    def eat(self):
        print('eat')
    def think(self,a,b):
        print(a+b)
        
class student(human): #学生类继承human这个父类
    stu1 = student()
    stu1.my_age()

运行结果：
human init
my age is 10

class student(human):#子类继承父类
    def __init__(self,grade=1,school='MIT'):
        super().__init__() #父类的初始化
        self.grade = grade
        self.school = school
        self.scroe = 100
        print('student init')
        
    #添加子类自己的方法
    def learn(self):
        print('learning')
    def my_school(self):
        print('my school is',self.school)
        
stu2 = student(4)
stu2.my_age()
stu2.learn()
stu2.my_school()

运行结果：
human init
student init
my age is 10
learning
my school is MIT

class student(human):#子类继承父类
    def __init__(self,grade=1,school='MIT'):
        super().__init__() #父类的初始化
        self.grade = grade
        self.school = school
        self.scroe = 100
        print('student init')
        
    #添加子类自己的方法
    def learn(self):
        print('learning')
    def my_school(self):
        print('my school is',self.school)
    #子类可以重写父类的方法
    def think(self,a,b):
        print(a*b)
        
stu3 = student()
stu3.think(10,20)

运行结果：
human init
student init
200

class12：input

class13：文件读写

class14：异常处理

class15：json数据存储