Python入门—基本语法
有标准C的基础，听过python大名：人生苦短，我用python！参照的课本是《Python编程：从入门到实践（第三版）》，IDE是Pycharm社区版，看的快，导致忘的也快，并且有些地方和C相似，容易弄混，所以记录下来，用于时常回顾下~
1. 变量和简单数据形式
- 在python中，用引号括起的都是字符串，其中的引号可以使单引号，也可以是双引号；
#title()函数是以首字母大写的方式显示单词，所以显示的是Fei Zhai Xiang
name='fei zhai xiang'
print(name.title())
#upper()是以全部大写的方式显示字符串，所以显示的是FEI ZHAI XIANG
name='fei zhai xiang'
print(name.upper())
#lower()是以全部小写的方式显示字符串，所以显示的是fei zhai xiang
name='FEI ZHAI XIANG'
print(name.lower())
#python用+号来连接字符串
first_name='fei'
middle_name='zhai'
last_name='xiang'
full_name=first_name+' '+middle_name+' '+last_name
print(full_name.title())
Python相对于标准C，最大的不同在于空格的使用，因为C对于空格并不敏感，而python对空格十分敏感，所以有了以下这些删除多余空格的函数；
#前后各加了一个空格，用函数rstrip()去除尾部空格，但不改变favorite_language中的值
favorite_language=' python '
print(favorite_language.rstrip())
#用lstrip()去除开头空格，且不改变favorite_language中的值
favorite_language=' python '
print(favorite_language.lstrip())
#用strip()同时剔除两端空格，且不改变favorite_language中的值
favorite_language=' python '
print(favorite_language.strip())
- 可调用函数str()，使非字符串值表示为字符串；
- python中以#作为注释的标识；
2. 列表简介
Python中的列表类似于C语言中的数组，只不过C语言中的数组需要给定类型：整形还是字符，并且，一个数组空间只能存一个数字或者是一个字符；在python中，每一个元素还能是字符串；
#第一个打印的结果是['rice', 'patato', 'tamato']，第二个打印的结果是rice
food=['rice','patato','tamato']
print(food)
print(food[0])
- 这里的元素可以直接用赋值的方式进行修改，
food=['rice','patato','tamato']
food[0]='orange'
print(food)
- 通过**append()**函数在列表末尾添加元素，用insert()函数在列表的任意位置添加新元素；
#打印出来结果是['rice', 'patato', 'tamato', 'orange']
food=['rice','patato','tamato']
food.append('orange')
print(food)
#打印出来结果是['rice', 'orange', 'patato', 'tamato']
food=['rice','patato','tamato']
food.insert(1,'orange')
print(food)
- 通过del语句 删除列表元素；
- 通过 pop() 函数删除列表元素，同时保留被删除的元素值；
- 通过 remove() 函数根据元素值来删除元素；
#打印出来结果是['patato', 'tamato']
food=['rice','patato','tamato']
del food[0]
print(food)
#打印出来结果是['patato', 'tamato'] 和 rice
food=['rice','patato','tamato']
poped_food=food.pop(0)
print(food)
print(poped_food)
#打印出来结果是['patato', 'tamato']
food=['rice','patato','tamato']
food.remove('rice')
print(food)
PS:若remove的值在列表中出现多次，只删除第一个指定的值。
- 通过 sort()函数 对列表进行永久性排序，按照字母顺序；
- 通过 sorted()函数 对列表进行临时排序；
#打印结果为['audi', 'bmw', 'subaru', 'toyata']
cars=['bmw','audi','toyata','subaru']
cars.sort()
print(cars)
#打印结果为['audi', 'bmw', 'subaru', 'toyata']和['bmw', 'audi', 'toyata', 'subaru']
cars=['bmw','audi','toyata','subaru']
print(sorted(cars))
print(cars)
- 通过 reverse()函数 对列表进行反转排序，即将原来的列表顺序反过来；
#打印结果为['subaru', 'toyata', 'audi', 'bmw']
cars=['bmw','audi','toyata','subaru']
cars.reverse()
print(cars)
- 通过 len() 函数 确定列表长度；
#打印结果为4
cars=['bmw','audi','toyata','subaru']
length=len(cars)
print(length)
3. for循环
在python中经常会使用for循环对列表进行遍历，和C语言类似，不一样的是没有C语言中的{}括号来讲循环体包括进去，取而代之的是缩进，即空格，通过下面的代码感受下：
#打印结果为 bmw
# audi
# toyata
# subaru
cars=['bmw','audi','toyata','subaru']
for car in cars:
print(car)
同时，整个for循环的条件语句也更接近自然语言，可以用 for value in key: 这种格式来记忆；
- 在for循环后面，没有缩进的代码只会执行一次，即缩进就是包含在循环体里面：
#输出结果为
# bmw
# It's brilliant car!
# audi
# It's brilliant car!
# toyata
# It's brilliant car!
# subaru
# It's brilliant car!
cars=['bmw','audi','toyata','subaru']
for car in cars:
print(car)
print("It's brilliant car!")
#输出结果为
# bmw
# audi
# toyata
# subaru
# It's brilliant car!
cars=['bmw','audi','toyata','subaru']
for car in cars:
print(car)
print("It's brilliant car!")
PS:for循环的条件语句后面的冒号，一定不要忘了。
4. if 语句
和for循环类似，if语句的用法和C语言很相似，同时用缩进代替了大括号，还有if条件和else条件后面也需要加一个冒号：
#打印结果为 BMW
# Audi
# Toyata
# Subaru
cars=['bmw','audi','toyata','subaru']
for car in cars:
if car == 'bmw':
print(car.upper())
else:
print(car.title())
在python中还多出了了一个叫 if-elif-else 的结构：
#打印结果为 BMW
# audi
# Toyata
# Subaru
cars=['bmw','audi','toyata','subaru']
for car in cars:
if car == 'bmw':
print(car.upper())
elif car == 'audi':
print(car.lower())
else:
print(car.title())
这里可以根据需求设置任意数量的elif代码块；
- python中数值的比较也和C语言中一样：用>，<，==，>=，<=等等表示；
- 但是用 and 替代了&&，用 or替代了||；
- 还有一种特殊的表达方式，用于判断特定值是否存在于列表中，用关键词 in 来表示，判断不在用 not in 表示：
#打印结果为 NO!
cars = ['bmw','audi','toyata','subaru']
car = 'bwm'
if car in cars:
print("YES!")
if car not in cars:
print("NO!")
5. 列表进阶
-可以通过 range() 函数创建数字列表：
#输出结果为[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
numbers = list(range(1,20,2))
print(numbers)
- range() 函数 括号中第一个数字代表起止数，第二个数字代表终止数，第三个数字代表步长，若以1为步长，则可以只写前两个数字；
- list() 函数将输出结果直接转换成列表；
- python支持列表的简单统计计算，最小值min()，最大值max()，求和sum()；
#输出结果为 1, 19 和 100
numbers = list(range(1,20,2))
print(min(numbers))
print(max(numbers))
print(sum(numbers))
- python中平方用 value2，立方用value3表示，下面的这种写法叫做列表的解析；
#输出结果为[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
#这里【】里面包含了一个for循环，相当于：
# numbers = list(range(1,11))
# squares = []
#
# for number in numbers:
# squares.append(number**2)
# print(squares)
squares = [value**2 for value in range(1,11)]
print(squares)
- 列表的切片可以按照列表原有顺序返回列表的任何一部分；
#输出结果是[3, 5]
numbers = list(range(1,20,2))
print(numbers[1:3])
#输出结果是[7, 9, 11, 13, 15, 17, 19]
numbers = list(range(1,20,2))
print(numbers[3:])
#打印结果是[1, 3, 5, 7]
numbers = list(range(1,20,2))
print(numbers[:4])
#打印结果是[15, 17, 19]，倒数三个
numbers = list(range(1,20,2))
print(numbers[-3:])
#打印结果是[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
numbers = list(range(1,20,2))
print(numbers[:])
6. 元组
元组可记忆为不可变的列表，与列表的区别：列表用【】，而元组用（）；
#打印结果为['hongqi', 'audi', 'toyata', 'subaru']
cars = ['bmw','audi','toyata','subaru']
cars[0] = 'hongqi'
print(cars)
#报错，元组的单个元素不可更改
cars=('bmw','audi','toyata','subaru')
cars[0]='hongqi'
print(cars)
#不会报错，输出结果为('hongqi', 'audi', 'toyata', 'subaru')
cars = ('bmw','audi','toyata','subaru')
cars = ('hongqi', 'audi', 'toyata', 'subaru')
print(cars)
元组的元素不可更改，但是整体可以重新赋值。
7. 字典
字典类似于C语言中的结构体，只不过是动态可变的，在初始定以后还能添加、修改、删除（del）属性值；
#打印结果为 green
# 5
alien_0 = {
'color':'green',
'points':5
}
print(alien_0['color'])
print(alien_0['points'])
#打印结果为{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
alien_0 = {
'color':'green',
'points':5
}
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
#打印结果为{'color': 'yellow', 'points': 5}
alien_0 = {
'color':'green',
'points':5
}
alien_0['color'] = 'yellow'
print(alien_0)
#打印结果为{'points': 5}
alien_0 = {
'color':'green',
'points':5
}
del alien_0['color']
print(alien_0)
- 通过 items() 返回字典中的键-值对，并将其以列表形式存储下来，通过for循环能够遍历字典；
#打印结果为 color
# green
#
# points
# 5
alien_0 = {
'color':'green',
'points':5
}
for key, value in alien_0.items():
print("\n"+key)
print(value)
- 通过 keys() 函数能够返回所有字典中的键名字，并形成列表；
#打印结果为 Color
# Points
alien_0 = {
'color':'green',
'points':5
}
for key in alien_0.keys():
print(key.title())
- 通过 values() 函数能够获得字典中的值列表；
#打印结果为 green
# 5
alien_0 = {
'color':'green',
'points':5
}
for value in alien_0.values():
print(value)
- 将字典作为元素存储在列表里，或者将列表作为字典中的值存储在字典中，我们称之为嵌套；
#这是将字典作为元素存储在列表里
alien_0 = {'color':'green','points':5}
alien_1 = {'color':'red','points':4}
alien_2 = {'color':'gray','points':6}
aliens =[ alien_0, alien_1, alien_2]
for alien in aliens:
print(alien)
#这是将列表作为字典中的值存储在字典中
aliens = {
'color' : ['green', 'red', 'gray'],
'points' : 5
}
for value in aliens['color']:
print(value.title())
还有一种方式是在字典中存储字典，不再详细展开。
8. 输入
Python中通过 input() 函数来输入，与C语言有两点不同：
- 输入默认为字符串格式，若想要改变格式，使用 int() 函数；
- 通常情况下使用 input() 函数， 括号里面会放入提示语言，即运行时，首先打印 input 的括号里面内容，然后输入；
#若输入19，打印结果为**Hello,lady!**
age = input('How old are you:')
if int(age)>18:
print("Hello,lady!")
else:
print("Hello,girl!")
9. while 循环
在python中的用法与在C语言中一样，同时也是用缩进替代大括号：
#这里python3.7不支持 ++ 的操作，pycharm报错
number = 1
while number < 10
print(number)
number += 1
- 在while循环中可以用 break 跳出循环；
- 可以通过 continue 回到循环开头；
while 循环同列表和字典结合使用，可用于收集、存储并组织大量输入；
#下面就是典型的一种用户列表验证结构
unconfirmed_users = ['alice', 'brain', 'candace']
confirmed_users = []
while unconfirmed_users:
current_user = unconfirmed_users.pop()
print('Verifying user: '+current_user.title())
confirmed_users.append(current_user)
print('\n All user have been verified!')
for confirmed_user in confirmed_users:
print(confirmed_user.title())
10. 函数
函数这里的用法与C语言类似，需要用到关键词 def ：
#这里传递了两个参数
def describe ( name, age ):
print("My name is "+name.title()+", and I'm "+ age +" years old!")
describe ('fei zhaixiang', '18')
- python中在函数这里，有一个很有趣的用法：默认值—在调用函数时，若提供了默认值，则在不提供实参的状态下可以直接使用默认值；
#这里年龄默认18，若不提供age这个实参，则默认为18
#打印结果为**My name is Fei Zhaixiang, and I'm 18 years old!**
def describe ( name, age = '18' ):
print("My name is "+name.title()+", and I'm "+ age +" years old!")
describe ('fei zhaixiang', )
- 有函数返回值的，只需要在函数体最后加一句 return xxx就可以，这里的返回值可以是字符串、数值、列表甚至是字典；
- 同时传递的实参也可以是列表；
- 当传递多个数量，甚至任意数量的实参时，可以将函数形参设置为元组，那么无论实参有多少个，都可以封装到这个元组中：
#打印结果为
# Making a pizza with following toppings:
# ('mushrooms', 'green peppers', 'extra cheese')
def make_pizza( *toppings ):
print("\nMaking a pizza with following toppings:")
print(toppings)
make_pizza('mushrooms', 'green peppers', 'extra cheese')
- 若在接受任意数量实参的同时还可能接受不同类型的实参，必须将任意数量实参的形参放在函数形参的最后一个：
#打印结果为
# Making a 16-inch pizza with following toppings:
# ('mushrooms', 'green peppers', 'extra cheese')
def make_pizza( size, *toppings ):
print("\nMaking a "+str(size)+"-inch pizza with following toppings:")
print(toppings)
make_pizza( 16,'mushrooms', 'green peppers', 'extra cheese')
- 在某些时候，我们在接受任意数量的实参时，不知道传递给函数，会是什么样的信息，可以在函数体内设置字典，将实参以键-值的形式存在字典内：
def build_profile( first, last, **user_info):
profile = {}
profile['first'] = first
profile['last'] = last
for key, value in user_info.items():
profile[key] = value
return profile
- 使用 import 关键字将其他 .py文件导入到当前文件中，其他 .py文件中放置函数主体，当前文件就可以将重点放在高层逻辑上了：
import module_name
module_name.function_name(xxx, xxx, xxx)
#若只需要导入特定函数
from module_name import function_name
- 如果要导入的名称可能与现有程序中的名称冲突，或者函数名太长，则可使用 as( 别名 ) ：
#as的一般用法如下
from module_name import function_name as fn
#当用as为其他.py文件制定名字时
import module_name as mn
#使用*运算符可导入模块所有函数，无需在本文件使用module_name.function_name(xxx, xxx, xxx)结构
#通常只使用在被导入.py文件相对较小的情况下
from module_name import *
以下是函数编写的一些规范：
- 函数名称应为描述性名称，且只使用小写字母和下划线；
- 注释中应该包括函数名称、需要的实参以及返回值类型；
11. 类
类中包含一个所描述对象的基本属性和一些方法（即类中的函数）：
class Car():
#这里的初始化属性，__init__（）的左右各两个下划线是一种约定，旨在避免方法与普通方法产生名称冲突
#self这个形参是自动传递的，记住就好，约定俗成
def __init__( self, maker, model, year ):
self.maker = maker
self.model = model
self.year = year
#类中的普通方法，形参一般为self
def get_descriptive_name( self ):
long_name = str(self.year) + ' ' + self.maker + ' ' + self.model
return long_name.title()
my_new_car = Car( 'audi', 'a4', 2019 )
print(my_new_car.get_descriptive_name())
-
属性值可以通过直接访问（即赋值）和类中的方法去更改；
-
继承是指在创建一个新的类时候，大多数属性可以用一个旧的类中的属性去描述，那么就可以用继承创建新类，只需要在 __init__模块中附属新的属性即可（需要注意的是创建子类时，父类必须包含在当前的文件中）；
-
若父类的方法不适用于子类，则可以重写，即在子类中定义同名方法，那么python会忽略父类同名方法；
class Car():
# 这里的初始化属性，__init__（）的左右各两个下划线是一种约定，旨在避免方法与普通方法产生名称冲突
# self这个形参是自动传递的，记住就好，约定俗成
def __init__(self, maker, model, year):
self.maker = maker
self.model = model
self.year = year
# 类中的普通方法，形参一般为self
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.maker + ' ' + self.model
return long_name.title()
class ElectricCar(Car):
# 只需要包含电动汽车的新属性即可
def __init__(self, maker, model, year, battery_size):
# 用super()关联父类和子类
super().__init__(maker, model, year)
# 新属性
self.battery_size = battery_size
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.maker + ' ' + self.model + ' ' + str( self.battery_size )
return long_name.title()
my_new_car = ElectricCar('audi', 'a4', 2019, 70)
print(my_new_car.get_descriptive_name())
- 当程序达到一定程度，需要从其他文件中导入类，方法和导入函数类似：
#这是导入一个类的模板
from module_name import object1_name
#这是导入两个类的模板，以此类推
from module_name import object1_name, object2_name
#这是导入一个模块所有类的模板
from module_name import *
类编码的方式需要注意：
- 类名的每个单词首字母用大写，并且不适用下划线；
- 实例和模块名用小写格式，并在单词之间加上下划线；
- 其余参照驼峰命名法；