计算材料学
0%

Python编程从入门到实践

发表于 更新于 分类于
本文字数： 9.1k 阅读时长 ≈ 8 分钟

书籍笔记

第一章：积累

  • int(a),float(a),eval(a)将字符串a编程数字格式
  • python会将非空的字符串理解为True
  • break跳出整个循环，continue跳出当前循环继续下一次循环

第二章：变量和简单数据类型

  • 变量能以字母和下划线开头，但不能以数字开头。

  • 大写字符串首字母用.title()

笔记中”>>>”代表程序输出，以后不再赘述

1
2
3
name = 'yaowei wang'
name.title()
>>> 'Yaowei Wang'
  • 字符串中写入变量
1
2
3
name = 'yaowei wang'
print(f'Hello, {name.title()}')
>>> Hello, Yaowei Wang
  • 去除字符串开头或者结尾的空白
1
2
3
4
5
6
7
8
9
favorite_language = ' python '
favorite_language.strip()
>>> 'python'
favorite_language.lstrip()
>>> 'python '
favorite_language.rstrip()
>>> ' python'
favorite_language
>>> ' python ' #此操作不会改变原始字符串
  • 同时给多个变量赋值
1
a,b,c = 1,2,3

第三章：列表

  • 列表中的索引从0开始

修改，添加，删除列表中的元素

修改列表元素

1
2
3
4
motor = ['honda','yamaha','suzuki']
motor[0] = 'wulinghongguang'
motor
>>> ['wulinghongguang', 'yamaha', 'suzuki']

添加元素

  • append在列表最结尾添加元素
1
2
3
motor = ['honda','yamaha','suzuki']
motor.insert(0,'wuling') #必须添加插入的位置
motor

删除列表中的元素

  • del语句
1
2
3
4
motor = ['honda','yamaha','suzuki']
del motor[0:2] #切片和索引删除都可以
motor 
>>> ['suzuki']
  • .pop()弹出
1
2
3
4
5
6
7
8
9
10
11
motor = ['honda','yamaha','suzuki']
while motor:
    print(motor.pop())
>>> suzuki
yamaha
honda
---------------
motor = ['honda','yamaha','suzuki']
a = motor.pop(1) #弹出特定位置的元素
print(a)
>>> yamaha
  • .remove()根据元素的值删除

组织列表

  • .sort()永久排序，sorted临时排序
1
2
3
4
5
6
alpha = ['a','c','b','d']
sorted(alpha)
>>> ['a', 'b', 'c', 'd']
alpha
>>> ['a','c','b','d']
alpha.sort() #永久变了

  • .reverse()永久反转列表

  • list(range(1,5)) #左闭右开区间，数字列表

1
2
3
4
5
6
num = list(range(1,9,2))
sum(num)
min(num)
max(num)
squares = [values**2 for value in range(1,11)]
>>> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  • 列表复制
1
2
3
4
5
6
7
8
my_food = ['carote','tomato','humberger']
friend_food = my_food[:] #复制成一个新的列表，不会改变原列表的值
my_food.append('apple')
friend_food.append('banana')
my_food
>>> ['carote', 'tomato', 'humberger', 'apple']
friend_food
>>> ['carote', 'tomato', 'humberger', 'banana']
  • 元祖中的元素不可以更改

第五章：if语句

  • .upper()将字符串所有的字母都大写 .lower()所有小写
1
2
3
4
5
6
7
8
9
age = 12
if age < 4:
  price = 0
elif age < 18:
  price = 25
else:
  price = 40
print(f'Your ad,ission cost is {price}')
# 如果有一个条件符合，就跳过其他条件

第六章：字典

{}中的键值对

  • 添加//修改/删除键值对
1
2
3
4
5
6
7
8
9
10
alien = {'color':'green', 'points':5}
alien['x_position'] = 3.0
alien
>>> {'color': 'green', 'points': 5, 'x_position': 3.0}
alien['points'] = 4
alien
>>> {'color': 'green', 'points': 4, 'x_position': 3.0}
del alien['points']
alien
>>> {'color': 'green', 'x_position': 3.0}
  • 访问字典中的值 .get()
1
2
alien.get('color')
>>> 'green'

  • 分别打印键值对/键/值 alien.items()/ alien.keys()/ alien.values()

  • set(列表名)，用来去除重复元素

第七章：用户输入和while循环

  • age = input(‘How old are you?’)

  • int(age)，将字符型的变量改成数字类型

  • 如果后面的条件满足while，循环就会一直进行下去

  • break永久退出循环，continue退出当前循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while True:
    city = input('Please input city name:')
    if city == 'quit':
        break
    else:
        print(f'I would like to go {city}')
        
current_number = 0
while current_number <= 10:
    if current_number % 2 == 0:
        continue
    else:
        print(current_number)
    current_number += 1

第八章：函数

  • 有默认参数的形参一定要放在函数定义的最后面
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 这样修改函数不会影响原来的列表
name = ['Tom','Bob']
a = name[:]

# 调用函数时若不给形参指定参数则会使用默认值,注意有默认值的参数一定要放在后面
def my_pet(pet_name,animal_type='dog'):
    print(f'I have a {animal_type.title()}')
    print(f'{animal_type.title()}\'s name is {pet_name}')
my_pet(pet_name='Wangcai')
print('-'*20)
my_pet(animal_type='cat',pet_name='Wangcai')
# 按照顺序赋予变量可以省略形参数的名字
print('-'*20)
my_pet('wangcai','pig')

# 让参数变成可选的,用None作为占位符号
def get_formatted_name(first_name,last_name,middle_name=None):
    if middle_name:
        full_name = f"{first_name} {middle_name} {last_name}"
    else:
        full_name = f"{first_name} {last_name}"
    return full_name.title()

student = get_formatted_name('yaowei','wang')
print(student)
print('-'*20)
s = get_formatted_name('yaowei','wang','ss')
print(s)

# 传入任意数量的实参数，*args，*让python创建了一个名为args的空元组，所有接收到的变量都会被封存到里面。
def make_pizza(*args):
    print('The following toppings are required in a pizza')
    for topping in toppings:
        print(f"- {topping}")
components = ['mushroom','tomato','cheese']
make_pizza(components)

# 传入任意数量的实参数,还有实参在一起;*arg表示任意数量的实际参数
def make_pizza(size,*args):
    print(f'The pizza is {size} inches')
    print('The following toppings are required in a pizza')
    for topping in args:
        print(f"- {topping}")
components = ['mushroom','tomato','cheese']
make_pizza('7',components)

# **一个星号是字符串，两个星号是字典；
# **user_info表示新建了一个空字典，注意字典的赋值方法
def make_profile(first_name,last_name,**user_info):
    user_info['first_name']=first_name.title()
    user_info['last_name']=last_name.title()
    return user_info
my_infomation = make_profile('yaowei','wang',Location='shanghai',School='SJTU')
print(my_infomation)

# 自己封装模块的方法
# user是python的文件名，make_profile是自己写的函数，可以把.py看成module？
import user as u
u.make_profile('yaowei','wang',Location='shanghai',School='SJTU')

第九章：类

  • 面向对象编程-

一、什么是面向过程？

面向过程是一种以过程为中心的编程思想，其原理就是将问题分解成一个一个详细的步骤，然后通过函数实现每一个步骤，并依次调用。
面向过程我们所关心的是解决一个问题的步骤，举个例子，汽车发动、汽车熄火，这是两个不同的事件，对于面向过程而言，我们关心的是事件本身，因此我们会使用两个函数完成以上两个动作，然后依次调用即可。

二、什么是面向对象？

面向对象则是一种以对象为中心的编程思想，就是通过分析问题，分解出一个一个的对象，然后通过不同对象之间的调用来组合解决问题。建立对象的目的不是为了完成某个步骤，而是为了描述某个事物在解决整个问题的过程中的行为。
如上面的例子，汽车发动、汽车熄火，对于面向对象而言，我们则关心的是汽车这类对象，两个事件只是这类对象所具备的行为。

三、面向对象的三大基本特征是什么？

1、封装

封装就是将一个类的某些信息隐藏在类的内部，不允许外界直接访问，而是提供某些方法实现对隐藏信息的访问和操作。
封装的好处就是增强了数据安全性以及隐藏了类的实现细节，使用者无需了解具体实现细节，只需通过特定的接口进行访问，这样也方便类自身的实现和修改。

2、继承

继承是类与类之间的一种关系，即子类继承父类的特征和行为，使得子类具有和父类相同的属性和行为。
继承的好处在于子类继承了父类的属性和方法从而实现了代码的复用。

3、多态

多态是指一个类对象的相同方法在不同情形下有不同的表现形式。
多态使得具有不同内部结构的对象可以共享相同的外部接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
# 类的首字母要大写，切后面没有括号，类要采用驼峰命名法
# 类中的函数成为方法，__init__是一种特殊方法
# self.name可以被类中的所用方法访问，其被称为属性
class Dog:
    '''我第一次写的小狗的类'''
    
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    def sit(self):
        print(f'{self.name} is sitting!')
    
    def rolling(self):
        print(f'{self.name} is rolling over!')
my_dog = Dog(name='Wangcai',age='6')
# 上面等价于my_dog = Dog('Wangcai','6')
my_dog.sit()

# 一个经典的汽车类例子
class Car:
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer = 0
        
    def get_name(self):
        print(f'{self.make} {self.model} {self.year}')
        
    def read_odometer(self):
        print(f'This car is {self.odometer} miles on it')
        
    def update_odometer(self,mileage):
        if mileage > self.odometer:
            self.odometer = mileage
        else:
            print('You can not roll back the odometer!')
    def increase_odometer(self,miles):
        if miles > 0:
            self.odometer += miles
        else:
            print('You can not roll back the odometer!')
            
class Electriccar(Car): #括号中要写父类的名字，下面有super
    def __init__(self,make,model,year):
        super().__init__(make,model,year)
        self.battery = Battery()
    
class Battery:
    def __init__(self,battery_size=75):
        self.battery_size=battery_size
        
    def describ_battery(self):
        print(f'The battery size is {self.battery_size} inches')
    
    def get_range(self):
        if self.battery_size == 75:
            range = 100
        else:
            range = None
        print(f'The car will run {range} miles')
        
my_car = Car('benz','A6','2020')
my_car.get_name()
my_car.read_odometer()
# 可以直接访问属性的类
print(my_car.odometer)

第十章：文件和异常

读取文件

with关键词之后不需要关闭文件；

1
2
3
4
5
6
7
with open('pi.txt') as f:
    contents = f.read()
print(contents)
# 一行行的读取
with open('pi.txt') as f:
    contents = f.readlines()
print(contents)

写入文件

1
2
3
4
5
6
7
8
'r' 可读模式，默认打开模式
'w' 写入模式，清空原始数据
'a' 附加模式,在原有的文本上继续写
'r+' 读写模式

with open('program.txt','w') as f:
    f.write('I love program!\n')
    f.write('That must be a joke!\n')

异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
try:
  print(5/0)
except ZeroDivisionError:
  print("You can not divede zero")
  # except后面可以指定特定的错误类型也可以不指定
  
def division(i):
    try:
        print(5/i)
    except :
#         print(f"{i} can not divede")
        pass
for i in [1,2,3,0,5]:
    division(i)
# 可以用pass直接跳过错误
>>>
5.0
2.5
1.6666666666666667
1.0

存储数据

JSON(Javascript Object Notation)最开始被java所用，后来被众多语言所共用;

json.dump存数据，json.load取数据

1
2
3
4
5
6
7
8
9
import json
numbers = list(range(11))
filename = "numbers.json"
with open(filename,'w') as f:
    json.dump(numbers,f)
    
with open(filename,'r') as f:
    content = json.load(f)
print(content)

第十五章：生成数据

  • matplotlib画图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import matplotlib.pyplot as plt

s = [i**2 for i in list(range(1,6))]
x = list(range(1,6))

# 注释掉的两行是查看python内置画图格式
# seaborn-darkgrid 
# plt.style.use('seaborn-darkgrid')
fig, ax = plt.subplots()
# 设置图名称和坐标轴标注
ax.set_title('Sum of squares',fontsize=24)
ax.set_xlabel('value',fontsize=24)
ax.set_ylabel('Sum of value',fontsize=24)
# 设置坐标轴数字的大小
ax.tick_params(axis='both',which ='major',labelsize=20)

ax.plot(x,s,lw=3)
# 注意是如何使用color map功能的
ax.tick_params(axis='both',which ='major',labelsize=20)
plt.savefig('test.pdf',dpi=500,bbox_inches='tight')
plt.show()
  • 一个随机漫步的类(定义类中的方法时要加self)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from random import choice
class RandomWalk:
    
    def __init__(self, num_points=5000):
        self.num_points = num_points
        
        self.x_values = [0]
        self.y_values = [0]
        
    def fill_walk(self):
        while len(self.x_values) <= self.num_points:
            x_direction = choice([-1,1])
            x_distance = choice([0,1,2,3,4,5])
            x_step = x_direction*x_distance
            y_direction = choice([-1,1])
            y_distance = choice([0,1,2,3,4,5])
            y_step = y_direction*y_distance
#             Do not stay at original point
            if x_distance == 0 and x_distance == 0:
                continue
            x_position = self.x_values[-1]+x_step
            y_position = self.y_values[-1]+y_step
            
            self.x_values.append(x_position)
            self.y_values.append(y_position)

import matplotlib.pyplot as plt
num = range(rw.num_points+1)
rw = RandomWalk(num_points=1000)
rw.fill_walk()
fig, ax = plt.subplots()

ax.scatter(rw.x_values,rw.y_values,c = num,cmap=plt.cm.Blues)
ax.scatter(rw.x_values[0],rw.y_values[0],c ='red')

第十六章：下载数据

1
2
#给指定区域着色
ax.fill_between(x,y_high,y_low,facecolor='blue',alpha=0.1)