Python编程基础总结——《Python编程从入门到实践》

引言：

“人生苦短，我用python”
python之禅：Simple is better than complex

目录：

1. 输入函数输出函数
2. 数据类型（字符串、数值、列表、元组、字典）
3. 结构语句（if条件语句、for循环、while循环）
4. 函数定义和类定义
5. 文件操作

1.输出函数&输入函数

• 输出函数：
  print（变量）
• 输入函数：
  变量=input（向用户显示的提示）
  input()函数让程序暂停运行，等待用户输入文本。获取用户输入后，python将其存储在一个变量中。
  input()得到的变量总是解读为字符串，需使用**int()**函数将输入转为数值。

2.数据类型

• 字符串：
  在python中，字符串变量可用单引号或双引号括起。
  支持的方法：
  .title()：首字母大写
  .upper()：全部大写
  .lower()：全部小写
  .strip()：剔除两端空白
  .lstrip()：剔除开头空白
  .rstrip()：剔除末尾空白
• 数值：
  整数和浮点数
  支持+、-、*、/、**(乘方)、%(取余)
  使用str()函数可将数值转变为字符串
• 列表：
  由一系列元素组成
  在python中，用方括号[ ]表示列表，并用逗号分隔
  索引从0开始，支持-1索引，表示倒数第一个
  访问：list[index]
  添加：list.append(value) ; list.insert(index,value)
  删除：del list[index] ; list.pop() ; list.pop(index) ; list.remove(value)
  排序：永久 list.sort() ; 临时 sorted(list)
  确定长度：len(list)
  使用range()函数生成一系列数字：range(1,5)=1,2,3,4
  生成数字列表：list(range(1,5,2))=[1,3]
  列表解析：list=[value**2 for value in range(1,3)] 此时list=[1,4]
  切边：list[0:3]，即取列表中索引值从0到3的元素构成一个列表
  可使用切片复制列表
• 元组：
  值不可修改的列表被称为元组
  在python中，用方括号( )表示元组，并用逗号分隔
  访问元素和列表一样
  虽然不可修改元组的值，但可给存储元组的变量重新赋值
• 字典：
  字典是一系列键-值对，键-值对应，与键对应的值可以是数字、字符串、列表、字典
  字典放在{ }内，键值之间用：分隔，而键值对之间用逗号分隔
  访问：value=dic[key]
  添加：dic[key]=value
  删除：del dic[key]
  遍历所有键值对：for key,value in dic.items()
  遍历所有键: for key in dic.keys() ; for key in dic
  遍历所有值：for value in dic.values()
  嵌套：字典作为列表元素；列表作为字典值；字典作为字典值

3.结构语句

（1）if语句
if 条件测试1：
\t语句1
elif 条件测试2：
\t语句2
else：
\t语句3

条件测试：
相等：==
不相等：！=
比较：< >
and 和 or 链接多个测试
in ; not in 判断特定值是否包含在列表中
列表是否为空

（2）for循环
列表遍历
for value in list:
\t语句
字典遍历
for value in dic:
\t语句
（3）while循环
while 条件测试：
\t语句

可使用break退出循环
使用continue退出本次循环

4.函数定义&类定义

• 函数定义：
  函数定义
  def fun():
  \t语句
  函数调用
  fun()
  传递实参
  位置实参：要求实参的顺序和形参相同
  关键字实参：每个实参由变量名和值组成
  可以传递列表，此时对列表会做出永久性修改，若不修改，可传递列表切片
  传递任意数量的实参：fun(*par) *让python创建一个名为par的空元组，将所有的值都传递到这个元组中。
  传递任意数量的关键字实参：fun(**par) **让python创建一个名为par的字典，将所有的名称-值对装到这个字典中。
  函数（fun1）可以存储在模块（case1.py）中：
  当在case2.py中调用fun1：
  import case1 as c1
  from case1 import fun1 as f1
  from case1 import *
• 类定义：
  类定义：
  class Cla():
  \t def init(self,par1,par2): #定义属性
  \t\t 语句1
  \t def way1(self): #定义方法
  \t\t 语句2
  创建实例：
  obj=Cla(pal1,pal2)
  属性和方法调用：
  Cla.par1
  Cla.par2
  Cla.way1()
  继承：
  一个类继承另一个类时，自动获得另一个类的所有属性和方法，同时还可以定义自己的属性和方法。
  class Cla2(Cla1):
  \t def init(self,par1,par2,par3):
  \t\t super().init(par1,par2) #调用父类的初始化函数
  \t\t 语句
  类的属性可接受一个实例
  导入类：
  from case1 import Cla1
  from case1 import *
  import case1

5.文件操作

读取整个文件
with open(‘路径’) as file_object:
\t contents=file_object.read()
\t print(contents)
逐行读取
with open(‘路径’) as file_object:
\t for line in file_object:
\t print(line)
创建一个包含文件各行内容的列表
with open(‘路径’) as file_object:
\t lines=file_object.readlines()
\t for line in lines:
\t\t print(line.rstrip())
读取文件时，python将其中所有文本解读为字符串

写入文件
with open(‘路径’，‘w’) as file_object:
\t file_object.write(value)
写入多行
with open(‘路径’，‘w’) as file_object:
\t file_object.write(value\n)
\t file_object.write(value\n)
附加到文件
不会覆盖原有内容
with open(‘路径’，‘a’) as file_object:
\t file_object.write(value\n)
\t file_object.write(value\n)

6.python代码实例：

#用到列表解析

def quicksort(arr):
    '''快速排序法'''
    if len(arr)<2:
        return arr
    else:
        pivot=arr[0] 
        less=[i for i in arr[1:] if ipivot]
        return quicksort(less)+[pivot]+quicksort(larger)
print(quicksort([1,5,3,2]))

#for循环

def findsmallest(arr):
    '''找列表中最小值'''
    smallest=arr[0]
    smallest_index=0
    for i in range(1,len(arr)):
        if arr[i]

#while循环

def binary_search(list,item):
    '''二分查找'''
    low=0 #起点
    high=len(list)-1 #终点
    while high>=low:
        mid=low+int((high-low)/2) #中间值
        if item==list[mid]:
            return mid
        elif item>list[mid]:
            low=mid+1;
        else:
            high=mid-1;
    return None
list=[1,2,3,6,9,10]
print(str(binary_search(list,6)))
print(str(binary_search(list,4)))

#字典

from collections import deque
'''图的形成'''
graph={}
graph["you"]=["alice","bob","claire"]
graph["bob"]=["anuj","peggy"]
graph["alice"]=["peggy"]
graph["claire"]=["thom","jonny"]
graph["anuj"]=[]
graph["peggy"]=[]
graph["thom"]=[]
graph["jonny"]=[]
print(graph)
'''广度优先搜索'''
def person_is_seller(name):
    '''定义一个供应商确定函数'''
    return name[-1]=="m"
def BFsearch(name):
    '''借助队列'''
    search_queue = deque()
    search_queue += graph[name]
    searched = []
    while search_queue:
        person = search_queue.popleft()
        if person not in searched:
            '''判断是否重复'''
            if person_is_seller(person):
                print(person+" is a seller!")
                return True
            else:
                '''否的话要将其朋友拉入队列'''
                search_queue += graph[person]
                searched.append(person)
    
    return False
print(BFsearch("you"))