emmm，这部分学的很累，也花了很长时间，但是工欲善其事必先利其器，基础是必不可少的。Python的语法相对来说比较接近自然语言，所以也比较好理解。但是，Python对空格很敏感，可能缺少一个空格就能导致整个程序运行不出来，所以，好的书写习惯有利于提高自己的编程效率。理论学完之后不一定能全部记住，需要通过大量的实践来巩固和加深。电子书资源见文尾，下次为大家推荐一些值得关注的公众号~
1、安装
单击Download下的Releases， 找到安装程序geany-1.25_setup.exe或类似的文件。 下载安装程序后， 运行它并接受所有的默认设置。
1）新建：安装完成后，新建文件，输入代码 print('Hello world!')
2）保存：文件命名以.py结束，.py指出这是一个Python程序；
3）运行：可在编辑器中直接‘执行’，也可以在windows终端运行
2、变量和简单的数据类型
1）变量：存储一个值
变量名只能包含字母、 数字和下划线，可以字母或下划线打头， 但不能以数字打头
变量名不能包含空格， 但可使用下划线来分隔其中的单词
不要将Python关键字和函数名用作变量名
变量名应既简短又具有描述性
慎用小写字母l和大写字母O， 因为它们可能被人错看成数字1和0
2）字符串：一系列字符
用引号括起的都是字符串，引号可以是单引号， 也可以是双引号
修改字符串大小写：全部大写 upper()，全部小写lower()，首字母大写title()
连接字符串：+
添加空白：制表符 \t，换行符 \n
删除空白：删除字符串开头和末尾多余的空白 rstrip()，剔除字符串开头的空白， 或同时剔除字符串两端的空白 lstrip() 和strip()
3）数字
整数：可进行+-*/运算，用两个乘号表示乘方运算
浮点数：带小数点的数
避免类型错误：转换为字符型 str()，不同类型变量不可以直接相加减
4）注释：# ctrl+E
5）Python之禅：在Python终端会话中执行命令import this
3、列表
由一系列按特定顺序排列的元素组成，在Python中， 用方括号[ ] 来表示列表， 并用，逗号来分隔其中的元素
1）访问列表元素
在Python中， 第一个列表元素的索引为0， 而不是1,索引指定为-1 ， 可让Python返回最后一个列表元素，以此倒推
bicycles=['trek','cannondale','redline']
print(bycycle[0])2）添加、修改和删除列表中的元素
修改：
bicycles=['trek','cannondale','redline']
bycycle[0]=‘honda’
print(bicycles)添加：列表附加元素时， 它将添加到列表末尾 append()，列表的任何位置添加新元素 insert(位置，内容)
删除：知道要删除元素的位置 del，从列表中删除， 并接着使用它的值 pop()，知道要删除的元素的值 remove()
3）组织列表
永久性排序：sort()，反向排序 sort(reverse=True)
临时排序：sorted()，反向排序 sorted(reverse=True)
反转元素排列顺序：reverse()
确定列表长度：len()
4、操作列表
1）遍历整个列表：for 变量 in列表：缩进
编写for 循环时， 对于用于存储列表中每个值的临时变量， 可指定任何名称
在for 循环中， 可对每个元素执行任何操作
位于for 语句后面且属于循环组成部分的代码行， 一定要缩进
for 语句末尾的冒号告诉Python， 下一行是循环的第一行，一定要加
2）创建数值列表
生成一系列的数字：range(开始，截止，步长)，指定的第一个值开始数， 并在到达你指定的第二个值后停止， 输出不包含第二个值
转换为列表：函数list() 将range() 的结果直接转换为列表 list(range(1,3))
统计计算：最大值 max()，最小值 min()，求和 sum()
列表解析：将for 循环和创建新元素的代码合并成一行， 并自动附加新元素，for 语句末尾没有冒号
3）使用部分列表
切片：[起始，终止（不包含该元素）]，若没有指定第一个索引， 自动从列表开头开始提取，若没有终止元素，则提取列表末尾的所有元素；负数索引返回离列表末尾相应距离的元素，如players[-3:]返回列表players最后三个元素
遍历切片 [:]
复制列表：可创建一个包含整个列表的切片， 方法是同时省略起始索引和终止索引 [:]
4）元组
列表适用于存储在程序运行期间可能变化的数据集，列表是可以修改的，元组是不可修改的列表。
定义：元组看起来犹如列表， 但使用圆括号()来标识
遍历：for循环
修改元祖变量：重新定义整个元组
5）代码格式
缩进：每级缩进4个空格
行长：小于80个字符
5、if语句
1）条件测试
每条if 语句的核心都是一个值为True 或False 的表达式， 这种表达式被称为条件测试
检查是否相等：= 区分大小写
检查是否不相等： ！=
检查多个条件：and or
检查特定值是否包含在列表： in/not in
布尔表达式：条件测试的别名
2）if语句
if-else语句
for megican in megicans:
if megican=='alice':
print(megican.upper())
else:
print(megican.title())if-elif-else 结构
相当于if-else if-else
3）用if语句处理列表
检查特殊元素
确定列表不是空的
6、字典
1）使用字典
字典：是一系列键—值对 。 每个键 都与一个值相关联， 你可以使用键来访问与之相关联的值，字典用放在花括号{}中的一系列键—值对表示。
访问字典：
alien_0={'color':'green','points':5}
print(alien_0['color'])
print(alien_0['points'])
添加键值对
alien_0={'color':'green','points':5}
print(alien_0)
alien_0['x_position']=25
alien_0['y_position']=5
print(alien_0)删除键值对 del alien_0['points']
2）遍历字典 for 循环
遍历所有键值对
user_0={
'user_name':'efermi',
'first':'enrico',
'last':'fermi',
}
for key,value in user_0.items():
print('\nKey: '+key)
print('Value: '+value)遍历所有键
for key in user_0.keys():按顺序遍历字典中所有键
for key in sorted(user_0.keys()):遍历所有值
for value in user_0.valuses():3）嵌套
将一系列字典存储在列表中， 或将列表作为值存储在字典中， 这称为嵌套
user_0={
'user_name':'amily',
'first':'ami',
'last':'lily',
}
user_1={
'user_name':'efermi',
'first':'enrico',
'last':'fermi',
}
users=[user_0,user_1]
for user in users:
print(user)
在字典中存储列表
pizza={
'crust':'thick',
'toppings':['mushrooms','extra cheese'],
}
print('You ordered a '+pizza['crust']+'-crust pizza '+'with the follwing toppings:')
for topping in pizza['toppings']:
print('\t'+topping)
在字典中嵌套字典
users={
'user_0':{
'first':'amily',
'last':'smith',
'location':'princeton',
},
'user_1':{
'first':'efermi',
'last':'curie',
'location':'paris',
},
}
for username,user_info in users.items():
print('\nUsername: '+username)
full_name=user_info['first'] + ' '+user_info['last']
location=user_info['location']
print('\tFull name: '+full_name.title())
print('\tLocation: '+location.title())7、用户输入和while循环
1）input()函数
原理
函数input() 让程序暂停运行， 等待用户输入一些文本。 获取用户输入后， Python将其存储在一个变量中。
message=input('Tell me something, and i will repeat it back to you: ')print(message)
有时候， 提示可能超过一行， 例如， 你可能需要指出获取特定输入的原因。 在这种情况下， 可将提示存储在一个变量中， 再将该变量传递给函数input()
message='Tell me something, and i will repeat it back to you'
message+='\nWhat do you want to say? '
something=input(messgae)
print('\nHello, '+something+'!')int()获取数值输入
使用函数input() 时，Python将用户输入解读为字符串，函数int() 将数字的字符串表示转换为数值表示。
age=input('How old are you? ')
age=int(age)
if age>=18:
print("\nYou're old enough to ride!")
else:
print("\nYou'll be able to ride when you're a little order.")求模运算符：% 两个数相除并返回余数
如果一个数可被另一个数整除， 余数就为0， 因此求模运算符将返回0，可利用这一点来判断一个数是奇数还是偶数。
number=input("Enter a number, and I'll tell you if it's even or odd:")
if int(number) %2==0:
print('\nThe number '+str(number)+' is even.')
else:
print('\nThe number '+str(number)+' is odd.')
2）while循环
current_number=1
while current_number<=5:
print(current_number)
current_number+=1
让用户选择何时退出
prompt='Tell me something, and i will repeat it back to you'
prompt+='\nEnter quit to end the program.'
message=''
while message!='quit':
message=input(prompt)
if message!='quit':
print(message)使用标志
在要求很多条件都满足才继续运行的程序中， 可定义一个变量， 用于判断整个程序是否处于活动状态。 这个变量被称为标志，可让程序在标志为True 时继续运行， 并在任何事件导致标志的值为False 时让程序停止运行。
prompt='Tell me something, and i will repeat it back to you'
prompt+='\nEnter quit to end the program.'
active=True
while active:
message=input(prompt)
if message=='quit':
active=False
else:
print(message)使用break退出循环
prompt='Tell me something, and i will repeat it back to you'
prompt+='\nEnter quit to end the program.'
while True:
message=input(prompt)
if message=='quit':
break
else:
print(message)
在循环中使用continue
current_number=0
while current_number<=10:
current_number+=1
if current_number%2==0:
continue
print(current_number)要返回到循环开头， 并根据条件测试结果决定是否继续执行循环， 可使用continue 语句
3）使用while循环来处理列表和字典
在列表之间移动元素
unconfirmed_users=['alice','brain','candy']
confirmed_users=[]
while unconfirmed_users:
current_user=unconfirmed_users.pop()
print('Veryfying user: '+current_user.title())
confirmed_users.append(current_user)
print('\nThe follwing users have been confirmed:')
for confirmed_user in confirmed_users:
print(confirmed_user.title())删除包含特定元素的所有列表元素
pet=['cat','dog','goldfish','dog','cat']
print(pet)
while 'cat' in pet:
pet.remove('cat')
print(pet)由用户输入来填充字典
responses={}
polling_active=True
while polling_active:
name=input('\nWhat is your name? ')
response=input('\nWhich mountain would you like to climb someday?')
responses[name]=response
repeat=input('\nWould you like to let another person respond?(yes/no)')
if repeat=='no':
polling_active=False
print('\n---Poll Results---')
for name,response in responses.items():
print(name+' would like climb '+response+'.')8、函数
1）定义函数
def 定义以冒号结尾
def greet_user(user_name):
print('Hello, '+user_name.title()+'!')
greet_user('jesse')实参和形参
变量user_name是一个形参 ——函数完成其工作所需的一项信息。 在代码greet_user('jesse') 中，值'jesse' 是一个实参 。 实参是调用函数时传递给函数的信息。
2）传递实参
位置实参
要求实参的顺序与形参的顺序相同
def describe_pet(pet_type,pet_name):
print('\nI have a '+pet_type+'.')
print('My '+pet_type+"'s name is "+pet_name.title())
describe_pet('hamster','Henrry')关键词实参
每个实参都由变量名和值组成，直接在实参中将名称和值关联起来了
def describe_pet(pet_type,pet_name):
print('\nI have a '+pet_type+'.')
print('My '+pet_type+"'s name is "+pet_name.title())
describe_pet(pet_type='hamster',pet_name='Henrry')默认值
编写函数时， 可给每个形参指定默认值 。 在调用函数中给形参提供了实参时， Python将使用指定的实参值； 否则， 将使用形参的默认值。
def describe_pet(pet_type=‘dog',pet_name):
print('\nI have a '+pet_type+'.')
print('My '+pet_type+"'s name is "+pet_name.title())
describe_pet('Henrry')3）返回值
函数返回的值被称为返回值，可使用return语句将值返回到调用函数的代码行。
返回简单值
def get_formatted_name(first_name,last_name,middle_name=''):
if middle_name:
full_name=first_name+' '+middle_name+' '+last_name
else:
full_name=first_name+' '+last_name
return full_name.title()
musician=get_formatted_name('jimi','hendrix')
print(musician)
musician=get_formatted_name('john','hooker','lee')
print(musician)返回字典
def person_name(first_name,last_name):
person={'first':first_name,'last':last_name}
return person
musician=person_name('jimi','hendrix')
print(musician)4）传递列表
def person_name(names):
for name in names:
msg='Hello '+name.title()+'!'
print(msg)
usernames=['jimi','hendrix','john']
person_name(usernames)在函数中修改列表
在函数中对这个列表所做的任何修改都是永久性的
unprinted_designs=['iphone case','robot pendant','dodecahedron']
complete_models=[]
while unprinted_designs:
current_design=unprinted_designs.pop()
print('Printing model:' + current_design)
complete_models.append(current_design)
print('\nThe following models have been printed:')
for complete_model in complete_models:
print(complete_model)可编写两个函数重新组织这些代码，效率更高。
def print_models(unprinted_designs,completed_models):
while unprinted_designs:
current_design=unprinted_designs.pop()
print('Printing model:' + current_design)
completed_models.append(current_design)
def show_compeled_models(completed_models):
print('\nThe following models have been printed:')
for completed_model in completed_models:
print(completed_model)
unprinted_designs=['iphone case','robot pendant','dodecahedron']
completed_models=[]
print_models(unprinted_designs,completed_models)
show_compeled_models(completed_models)5）传递任意数量的实参
Python允许函数从调用语句中收集任意数量的实参，星号* 让Python创建一个名为toppings 的空元组， 并将收到的所有值都封装到这个元组中。
def make_pizza(*toppings):
print(toppings)
make_pizza('pepperoni')
make_pizza('mushroom', 'green peppers', 'extra cheese')结合使用位置实参和任意数量实参
def make_pizza(size,*toppings):
print('\nMaking a '+str(size)+'-inch pizza with the following toppings:')
for topping in toppings:
print('- '+topping)
make_pizza(16,'pepperoni')
make_pizza(13,'mushroom', 'green peppers', 'extra cheese')使用任意数量的关键字实参
**user_info 中的两个星号让Python创建一个名为user_info 的空字典， 并将收到的所有名称—值对都封装到这个字典中。
def build_profile(first,last,**user_info):
profile={}
profile['first_name']=first
profile['last_name']=last
for key,value in user_info.items():
profile[key]=value
return profile
user_profile=build_profile('albert','einstein',
location='princetion',
field='physics')
print(user_profile)5）将函数存储在模块中
将函数存储在被称为模块 的独立文件中，再将模块导入 到主程序中。import 语句允许在当前运行的程序文件中使用模块中的代码。模块 是扩展名为.py的文件， 包含要导入到程序中的代码。
导入整个模块
def make_pizza(size,*toppings):
print('\nMaking a '+str(size)+'-inch pizza with the following toppings:')
for topping in toppings:
print('- '+topping)将上述内容保存为pizza.py文件，再使用下面的调用语句
import pizza
pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushroom', 'green peppers', 'extra cheese')导入特定的函数
from module_name import function_0, function_1, function_2
from pizza import make_pizza
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushroom', 'green peppers', 'extra cheese'使用as 给函数指定别名
from pizza import make_pizza as mp
mp(16, 'pepperoni')
mp(12, 'mushroom', 'green peppers', 'extra cheese')使用as 给模块指定别名
import pizza as p
p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')导入模块中的所有函数
使用星号（* ） 运算符可让Python导入模块中的所有函数
from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushroom', 'green peppers', 'extra cheese')9、类
1）创建和使用类
在Python中，创建类以class开头，首字母大写的名称指的是类，小写的名称指根据类创建的实例。
创建Dog类
class Dog():
def __init__(self,name,age):
self.name=name
self.age=age
def sit(self):
print(self.name.title()+' is now sitting.')
def roll_over(self):
print(self.name.title()+' rolled over!')!注意！init左右两边有两个_，方法__init__() 定义成了包含三个形参： self 、 name 和age 。 在这个方法的定义中， 形参self 必不可少， 还必须位于其他形参的前面。每个与类相关联的方法调用都自动传递实参self ， 它是一个指向实例本身的引用， 让实例能够访问类中的属性和方法。
根据类创建实例
my_dog = Dog('willie',6)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")2）使用类和实例
Car类
class Car():
def __init__(self,make,model,year):
self.make=make
self.model=model
self.year=year
def get_descriptive_name(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name.title()
my_new_car=Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())给属性指定默认值
class Car():
def __init__(self,make,model,year):
self.make=make
self.model=model
self.year=year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name.title()
def read_odometer(self):
print(‘This car has ’+str(self.odometer_reading)+'miles on it.')
my_new_car=Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()修改属性的值
my_new_car.odometer_reading = 23
my_new_car.read_odometer()3）继承
如果你要编写的类是另一个现成类的特殊版本， 可使用继承 。 一个类继承 另一个类时， 它将自动获得另一个类的所有属性和方法； 原有的类称为父类 ， 而新类称为子类 。 子类继承了其父类的所有属性和方法， 同时还可以定义自己的属性和方法。定义子类时， 必须在括号内指定父类的名称。super() 是一个特殊函数， 帮助Python将父类和子类关联起来。
子类的方法__init__()
class Car():
def __init__(self,make,model,year):
self.make=make
self.model=model
self.year=year
self.odometer_reading=0
def get_descriptive_name(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name.title()
def read_odometer(self):
print(‘This car has ’+str(self.odometer_reading)+'miles on it.')
def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
self.odometer_reading += miles
class ElectricCar(Car):
def __init__(self, make, model, year):
super().__init__(make, model, year)
self.battery_size = 70
def describe_battery(self):
print("This car has a " + str(self.battery_size) + "-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_new_car.get_descriptive_name())
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()作者：马小野
