环境
- anaconda
- 安装单纯的python，单独安装各类库。pycharm 注册码在lanyu查询，会更新
- linux环境下安装python软件在github或者码云获取，文档在获取
基础语法与用法
- 变量名：_XXX_系统内定的。__私有变量.大小写字母数字下划线构成，数字不能作为开头。变量名都是小写开头（eg. dologin，全小写），函数（eg.\doLogin\do_login,头小写，单词大写）类名大写开头(eg.TopicInfo，头大写，单词大写)
- 关键字：关键字不可以用为变量名，会出错。
- 变量与常量:常量（eg.1 ，2 ，3，可以看到内容的），变量（eg. a=123，a=234，a就是变量，定义变量方法为：变量名 = 数据）
基础内容
- 数据：
- 不可变数据（number数字，string字符串，tuple元祖）
- 可变数据（list列表，dictionary字典，set集合）列表和字典常用，必须掌握
- 类型判断:type(object)
- 类型转换:
- int(x [,base])
将x转换为一个整数- float(x)
将x转换到一个浮点数- complex(real [,imag])
创建一个复数- str(x)
将对象 x 转换为字符串- repr(x)
将对象 x 转换为表达式字符串- eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象- tuple(s)
将序列 s 转换为一个元组- list(s)
将序列 s 转换为一个列表- set(s)
转换为可变集合- dict(d)
创建一个字典。d 必须是一个序列 (key,value)元组。- frozenset(s)
转换为不可变集合- chr(x)
将一个整数转换为一个字符- ord(x)
将一个字符转换为它的整数值- hex(x)
将一个整数转换为一个十六进制字符串- oct(x)
将一个整数转换为一个八进制字符串
- 索引：索引值都是从0开始，
- 转义：eg（print（‘xxx\nyyy’）=xxx 换行yyy ，print（r'xxx\nyyy）=xxx\nyyy）
- 运算符:in/not in是否包含
- 格式串:
- eg.a=123 b=234 print('{},{}'.format(a,b))
- 使用%占位符eg.a=123 b=234 print('%d,%d'%(a,b))，
列表数据(有序可重复，所有数据都可以放，建议同类数据放到一个list中）
- 用法 a=[]
- 索引：
下标索引:索引值从0开始，
数据内容中如果是另一个列表就用【】【】的方法索引 ，- 遍历:
for 循环遍历所有数据eg1. for x in list，eg2.for i in range(0,len（list）) list[i]
元祖数据（使用机会较少，不可修改）
- 用法 a=（），如果创建只有一个元素的元祖数据，一定要在结尾有（，）逗号
- 索引：
下标索引:索引值从0开始，
数据内容中如果是另一个列表就用【】【】的方法索引 ，
- 遍历:
for 循环遍历所有数据eg1. for x in tuple，eg2.for i in range(0,len（tuple）) tuple[i]
集合数据（有序不重复）
- 用法 a={}
- 索引：
下标索引:索引值从0开始，
数据内容中如果是另一个列表就用【】【】的方法索引 ，
- 遍历:
for 循环遍历所有数据eg1. for x in set，eg2.for i in range(0,len（set）) set[i]
字典数据（键值对，非常常用，不可变数据）
- 用法 a={key：value}，key必须是唯一的
- 修改：key=value
- 删除：del dict['Name']，dict.clear()全部删除,dict.pop('Name')
- 使用:
- copy() 方法返回一个字典的浅拷贝
dict1 = {'Name': 'Neuedu', 'Age': 7, 'Class': 'First'}
dict2 = dict1.copy(),
print ("新复制的字典为 : ",dict2),
新复制的字典为 : {'Age': 7, 'Name': 'Neuedu', 'Class': 'First'}- get(key, default=None)方法返回指定键的值，如果值不在字典中返回默认值,
dict = {'Name': 'Neuedu', 'Age': 27}
dict.get('Age')),
27
dict.get('Sex', "NA")),
NA- items()方法以列表形式返回可遍历的(键, 值) 元组列表,
dict = {'Name': 'Neuedu', 'Age': 7}
dict.items()
dict_items([('Age', 7), ('Name', 'Neuedu')])- keys() 方法将字典中所有的键返回一个可迭代对象，可以使用list() 来转换为列表,
dict = {'Name': 'Neuedu', 'Age': 7}
dict.keys()
dict_keys(['Name', 'Age']),
list(dict.keys()) # 转换为列表
['Name', 'Age']
-fromkeys(seq[, value]) 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值,
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" % str(dict))
新的字典为 : {'age': None, 'name': None, 'sex': None}
流程控制
- if 条件表达式1:
语句块1
elif 条件表达式2:
语句块2
else:
语句块3- 产生循环数：
使用随机数，先导入随机数模块，再使用 random.randint(a, b)返回 [a, b] 之间的整数（包含 a 和 b），
import random
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20
random.randint(20, 20) # 结果永远是 20
random.randint(20, 10) # 该语句是错误的，下限必须小于上限
3.循环结构
- while：
while 条件表达式：
语句块
更新条件表达式
else ：
语句块
eg:
...
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n,sum))
...- for
- continue:continue 条件满足时，不执行后续的代码，直接进入下次循环.只针对 当前所在循环有效
- break:break 条件满足时，退出循环，不再执行后续重复的代码.只针对当前所在循环 有效
- 计数用range（）
函数
- 用法：
def 函数名( 形参表 ) :
函数体
[ return [ 表达式/函数 ] ]- 类型
- 无参函数
def hello() :
print("Hello World!")- 带参函数
def area(width, height):
return width * height- 空函数
def nop(): # 一个什么事也不做的空函数
pass
参数
1.实参：
不可变类型：数字、字符串、元组作为 实参 时，会将副本传递给 形参 ，因此函数内部的修改不会影响 实参 本身，
可变类型：列表、字典、集合作为 实参 时，会将 实参 真正的传过去，因此函数内部的修改也会对 实参 产生影响
- 形参:
- 必选参数（位置参数），要求 实参 必须以正确的顺序和数量传递给 形参 。
def printme( str ):
print (str)
printme() # 报错，实参数量不正确- 关键字参数，将 实参 以赋值语句的形式传递给指定的 形参，允许函数调用时参数的顺序与声明时不一致，由解释器负责匹配
def printinfo( name, age ):
print ("名字: ", name)
print ("年龄: ", age)
printinfo( age=50, name="neuedu" )- 默认参数，为 形参 设置默认值，当没有 实参 时使用该值
def printinfo( name, age = 35 ): # 形参的默认值为35
print ("名字: ", name)
print ("年龄: ", age)
printinfo( age=50, name="neuedu" )
printinfo( name="neuedu" ) # 在函数中使用age的默认值
名字: neuedu
年龄: 50
名字: neuedu ,
年龄: 35- 不定长参数，当 实参 数量不定时，可以使用不定长参数。
def printinfo( arg1, *vartuple ):
print(arg1)
print(vartuple)
printinfo( 70, 60, 50 )
70
(60, 50)- 在Python中 形参可以用必选参数、默认参数、可变参数、关键字参数、命名关键字参数。
但定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数、关键字参数。
对于任意函数，都可以通过类似 func(*args, **kw) 的形式调用它，无论它的参数是如何定义的
虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。
面向对象（类）
-
概念
- 类：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
- 方法：类中定义的函数。
- 实例化：创建一个类的实例，类的具体对象。
- 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
- 局部变量：定义在方法中的变量，只作用于当前实例的类。
- 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
- 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
-
基本语法
创建类
class 类名:
def方法名(self [,参数列表]):
pass
创建对象
对象变量 = 类名( [ 参数列表 ] )
class Cat:
def eat(self):
print("小猫爱吃鱼")
def drink(self):
print("小猫在喝水")
tom = Cat()
print(tom)
<__main__.Cat object at 0x00000000029BF0B8>
tom.drink()
tom.eat()
小猫在喝水
小猫爱吃鱼
定义一个属性
class Cat:
def __init__(self, name):
self.name = name # 添加name属性
def eat(self):
print("小猫%s爱吃鱼" % self.name)
def drink(self):
print("小猫%s在喝水" % self.name)
tom = Cat("Tom")
tom.eat()
tom.drink()
小猫Tom爱吃鱼
小猫Tom在喝水
类实例
创建家具类
class HouseItem:
def __init__(self, name, area):
self.name = name
self.area = area
def __str__(self):
return "[%s] 占地面积 %.2f" % (self.name, self.area)
bed = HouseItem("席梦思", 4)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)
print(bed)
print(chest)
print(table)
[席梦思] 占地面积 4.00
[衣柜] 占地面积 2.00
[餐桌] 占地面积 1.50
创建家类
class House:
def __init__(self, house_type, area):
self.house_type = house_type
self.area = area
self.free_area = area
self.item_list = []
def __str__(self):
return ("户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s"
% (self.house_type, self.area,
self.free_area, self.item_list))
def add_item(self, item):
print("要添加 %s" % item)
my_home = House("两室一厅", 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)
要添加 [席梦思] 占地面积 4.00
要添加 [衣柜] 占地面积 2.00
要添加 [餐桌] 占地面积 1.50
户型：两室一厅
总面积：60.00[剩余：60.00]
家具：[]
添加家具方法
def add_item(self, item):
print("要添加 %s" % item)
if item.area > self.free_area:
print("%s 的面积太大，不能添加到房子中" % item.name)
return
self.item_list.append(item.name)
self.free_area -= item.area
异常处理
1.语法(Exception全部异常）
try:
会引发异常的代码
except 异常类名1 [ as 异常变量名]:
处理异常1的代码
except 异常类名2 [ as 异常变量名]:
处理异常2的代码
...
else:
没有异常时执行的代码
finally:
无论是否有异常，都会执行的代码
- 异常的传递
- 当函数或方法执行出现异常时，会将异常传递给调用者，如果传递到主程序，仍然没有异常处理，程序才会被终止
- 因此，只要在合适的层次去捕获错误就可以
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
print('Error:', e)
finally:
print('finally...')
- 抛出异常
- 语法格式：raise [ 异常对象 ]
def input_password():
pwd = input("请输入密码：")
if len(pwd) >= 8:
return pwd
else:
ex = Exception("密码长度不够")
raise ex
try:
user_pwd = input_password()
print(user_pwd)
except Exception as result:
print("发现错误：%s" % result)