Python基础

简介

Python是由荷兰数学和计算机科学研究学会于上世纪九十年代初设计的提供了 高效的高级数据结构 ，还能 简单有效地面向对象编程 的高级程序语言

Python语法和动态类型，以及 解释型语言 的本质，使它成为多数平台上写脚本和快速开发应用的编程语言， 随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发（后端，运维，人工智能，数据分析等）。

语法基础

·基本输出

print('Hello World')	# 输出内容并换行

注：Python中不区分单/双引号，但使用时可以用于区分字符或字符串，也可用于区分转义字符（如字符串中用到单引号）

·变量

Python中的基本变量有number(int, float,bool,complex(复数))，float，str

在Python中bool是int的子类，可以和数字运算

name='Carol'		# str
age=20				# number
weight=100.5		# float
isMarriaged=False	# bool

注：命名的方式

• 大驼峰：IsMarriaged
• 小驼峰：ismarriaged
• 下划线：is_marriaged

类型转换：

print(type(str(weight)))	# 输出转换后的类型
print(name+str(age))		# 输出拼接字符串
# 非字符串类型不可拼接

·输入输出

输出即print语句

print('My name is', name)					# 输出时‘’结尾带空格
print('My name is %s age:%d' % (name, age))	# %后为内容填充

.format()格式

print('My name is {} age:{}'.format(name, age))		# .format()按列表格式输出
print('age:{1} My name is {0}'.format(name, age))	# 指定填充目标
print('spend {:.2f}'.format(1.73205))				# 指定输出格式

占位符

print('%d%%' % percentage)	# 占位符显示
print('{}%'.format(percentage))

输入即input语句

title = input()	 # input()只能输入字符串

price = int(input('input the price '))
weight = float(input('input the weight '))
print("total = %.2f" % (price * weight))

·运算符

常用算数运算符有+，-，*，/，//，**，%

print(1+2)
print(2-1)
print(1*3)
print(3/2)		# 取商(真值)
print(3//2)		# 取商(向下取整)
print(3**2)		# 取幂(3的2次方)
print(4%3)		# 求余

逻辑运算符

and				# 布尔与
or				# 布尔或
not				# 布尔非

成员运算符

in				# 是否在指定序列中
not in

a = 1
b = 10
list = [1, 2, 3, 4, 5]
if(a in list):
	print(a)

if(b not in list):
	print(b)

身份运算符

is				# 判断两个标识符是否引用自一个对象
is not			# 判断依据为内存地址

注：is和==的区别
is判断的是变量引用对象是否为同一个（地址）
后者判断的是变量的值是否相等

·分支语句

使用if，elif，else关键字，用键入控制结构

score = float(input('input your score '))
if score >= 80:
    print('Excellent')
elif score >= 60:
    print('Good')
else:
    print('Failed')

注：

• if和elif后写条件后加“:”，else后直接加“:”
• 多个条件表达式根据 与 或 逻辑用 and or 连接
• 分支结构可嵌套

·循环语句

while循环

i = 1					# 输出12345
while i <= 5:
    print(i, end='')	# 取消换行
    i += 1

for循环
range的三个参数为初始值，终值（不包括），步长（默认为1，可为负数）

for i in range(1, 10, 2):
    print('%d ' % i, end='')

注：range参数后加“:”，循环可嵌套
whlie循环需先申请循环控制变量

·列表 list

python的列表是一种有序表，形式list = [‘Google’, ‘Runoob’, 1997, 2000]

CL = []					# 创建空列表，也可创建有元素的
CL.append('Computer')	# 列表尾添加
CL.insert(1,'English')	# 根据索引插入
CL[1] = 'Math'			# 根据索引修改

print(CL[1])			# 根据索引输出，查询
print(CL)				# 完整格式输出列表
CL.pop()				# 默认删除尾部，可指定索引，并返回其值
CL.remove('Computer')	# 指定内容删除

列表元素可以为任意类型

List = [3, 4, 2, 1, 6, 5, 7, 2]
List.sort()   			# 列表内容排序，默认为升序
List1 = sorted(List)  	# 不会改变原列表
List2 = List[1:5:2]		# 列表切片，参数为起始，终止（不包括该元素），步长
List.reverse()  		# 反转

print(len(List))		# 列表长度
print(max(List))		# 求最大值，也可求最小值
print(List.count(2))	# 参数出现的次数
print(2 in List)		# 参数是否存在，not in为是否不存在

for i in myList:  		# 遍历列表，迭代
    print('%d ' % i, end='')

注：索引可以从头开始，第一位为0，第二位为1，也可以从尾部开始，最后一位为-1，倒数第二位为-2

·字典 dict

本质上是 键值对 key=value,列表和字典不能当成键，无序，形式dict = {key1 : value1, key2 : value2, key3 : value3 }

d = {}						# 创建空字典，也可创建有元素的
d['name'] = 'Carol'			# 创建字典信息
d['age'] = 20
d.setdefault('name', 'xxx') # 若不存在键则插入，存在则不做处理

print(d['age'])				# 根据键来查找
print(d.get('age'))
d['age'] = 21  				# 根据键修改值
print(d)					# 按格式输出字典

d1 = {"gender": 'woman'}	# 合并两个字典
d.update(d1)  				
d.pop('name')  				# 根据键来删除

for i, j in d.items():		# 遍历字典（仅键值对）
    print(i, j)
    
d.clear()  					# 清空字典

print(d.keys())				# 遍历已有键
print(d.values())			# 遍历已有值
print(d.items())			# 遍历已有项

·元祖 tuple

元组与列表类似，不同之处在于元组的元素不能修改，t = (1, 3, 2, 3)

t = (1, 3, 2, 3)	# 创建后不可更改
t1 = (1,)			# 只有一个元素时声明要加逗号

print(t)			# 按元祖格式输出	
print(t[2])			# 按索引查找
print(t[1:3])		# 按元祖格式输出起始到终止(不包括)的元素

t[1] = 2			# 错误写法，元祖的元素不可变
t2 = t + t1			# 元祖连接，不同数据类型也可连接
del t				# 元素不可删除，只能删除整个元祖

注：python中的对象类型可分为 可变（引用）类型 和 不可变（值）类型

• 可变（引用）类型：列表，字典，集合
• 不可变（值）类型：int，float，str，bool，元组

区别：

• 可变（引用）类型：数据发生改变时，地址不变
• 不可变（值）类型：数据发生改变时，地址也改变

·集合 set

集合是一个无序的 不重复元素 序列，形式：s1 = {1, 2, 3}，注意与集合的键值对区分，自动排序

ss = {1, 2, 3}			# 创建空集合不可写s1={}，这会创建空字典
s = set()				# 创建空集合必须写set()关键字

s.add(2)				# 添加元素，若存在则不操作
s.update([8, 5]) 		# 添加元素，参数可以是列表，元组，字典等，也可有多个参数

s.pop()  				# 删除首位
s.remove(6)  			# 按值删除，不存在会发生错误
s.discard(7)  			# 存在则删，不存在则不操作

print(len(s))			# 求元素个数
s.clear()				# 清空集合
print(1 in s)			# 元素是否存在

集合运算操作

s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1 & s2)  		# 交运算 3
print(s1 | s2)			# 并运算 1，2，3，4，5
print(s1 - s2)			# 差运算 1，2，4，5

·函数

函数是组织好的，可重复使用的，用来实现 单一 ，或相关联功能的代码段

def show(fName, fAge):			# def关键字，后为函数名和参数列表，“:”不可省
    print('%s' % fName)			# 函数体，用键入格式控制
    print('%d' % fAge)			# 不写返回值则相当于返回None

def add(x1, x2):
    return x1 + x2

def addx(x1=2, x2=3):  			# 带默认值
    return x1 + x2

global name, age  				# 声明下用变量为全局变量，才可对全局做更改
def show():
    name = 'Carol'
    age = 21
    return name, age  			# 可以元组形式返回多个值

fun = lambda a, b: a + b  		# 匿名函数，没有名字，只能有一个式子
res = fun(1, 2)					# “:”前为参数，后为返回值

传输不定长参数的函数
加了“ * ”的参数会以元组的形式导入，存放所有未命名的变量参数
加了“ ** ”的参数会以字典的形式导入

def show(x, y, *args, **kwargs):	# 可变参数,参数过多时
    print(x, y)
    print(*args)  					# 拆包输出，仅数据
    print(args)  					# 不拆包输出，即输出元组形式
    print(kwargs)  					# 字典形式

show(1, 2, 3, 4, 5, a=1, b=2)		#1，2对应x，y；3，4，5对应元祖，其后对应字典

上述“show”函数最终输出为

1 2
3 4 5
(3, 4, 5)
{'a': 1, 'b': 2}

·面向对象

面向对象是一种编程思想

• 类：具有相同属性或相同行为的一类事物，类是抽象的
• 对象：类的实例，对象是具体的

 class Person():
    def __init__(self, fname, fage):	# 构造方法，实例化对象时最先执行
        self.name = fname
        self.age = fage

    def __str__(self):					# 控制格式化输出
        # 必须有返回值
        return self.name, self.age

    def eat(self):						# 普通成员方法
        print('eat')

person1 = Person('Carol', 20)			# 调用过程
print(person1.__str__())
person1.eat()

封装

将属性或方法设为私有，仅允许类内访问

class Person():
    def __init__(self, fname, fage):
        self.name = fname
        self.__age = fage				# 将年龄设为私有属性，前缀双下划线
        
	def getAge(self):					# 利用公有方法访问
		return self.__age				# 访问此私有属性也要带双下划线
		
	def __setAge(self,fage):			# 设定为私有方法，即不能在类外调用以改变属性等，
		self.__age=fage					
	def update(self,fage):				# 只可通过类内方法间接调用
		self.__setAge(fage)
										# 类外直接访问私有属性是不允许的
person = Person('Carol',20)
# person.__setAge(18)					# 不允许此写法
person.update(18)
print(person.getAge())