Python 基础学习
1、学习路线
根据下图的Python路线进入Python学习之旅。python
2、数据类型
学习一门编程语言，首先得学习它的数据类型和语法。基于如今的趋势，全部的都是基于Python3的学习。
复制代码
Python 的基本数据类型有如下几类：git
1. 数字（int）类型：int、float、complex
2. 布尔型（bloo）
3. 字符串（str）
4. 列表（list）
5. 元组（tuple）
6. 字典（dict）
7. 集合（set）
复制代码
1. 数字类型（int）
Python3中，不管整数的大小长度为多少，统称为整型int。 【GitHub代码commits id：b0f0c81】github
power_int = 2 ** 40
print("power_int：", power_int)
print("power_int_type：", type(power_int))
str_int = int('123')
print("str_int_type：", type(str_int))
bit_length_int = 123
print(bit_length_int.bit_length())
复制代码
2. 布尔类型（bool）
对于 bool 类型来讲，只存在两种值 True 和 False，对应的二进制值分别是 1 和 0。True的值太多，但 False 的值能够穷举：None, 空（[], (), {}, ""）, 0。【GitHub代码commits id：e420fc2】编程
none_value = bool(None)
print("none_value: ", none_value)
blank_1 = bool([])
print("blank_1: ", blank_1)
blank_2 = bool({})
print("blank_2: ", blank_2)
blank_3 = bool("")
print("blank_3: ", blank_3)
blank_4 = bool(())
print("blank_4: ", blank_4)
zero_value = bool(0)
print("zero_value: ", zero_value)
复制代码
3. 字符串（str）
字符串可由单引号或双引号来建立，字符串是不可修改的，字符串可进行如下操做【GitHub代码commits id：4abe110】：api
（1）索引
（2）切片
（3）长度
（4）遍历
（5）删除
（6）分割
（7）替换
（8）链接
（9）大小写替换
（10）判断以什么开头
（11）判断字符串的内容
（12）格式话输出
（13）扩展
复制代码
# 3.1 索引
#   index() 和 find() 的区别：若索引的字符串或序列不在字符串内，index--->返回的是ValueError：subString not found，而find--->返回 -1。
string1 = "没有什么独特"
index_str = string1.index("没", 0)
print("index_str: ", index_str)
find_str = string1.find("有", 2)
print("find_str: ", find_str)
# 3.2 切片
string2= "这是一首简单的歌"
section_str = string2[0: 1]
print("section_str: ", section_str)
# 3.3 长度
string3 = "试着带入个人心事"
len_str = len(string3)
print("len_str: ", len_str)
# 3.4 遍历
string4 = "它那么幼稚"
for ergodic_str in string4:
print("ergodic_str: ", ergodic_str)
for index in range(len(string4)):
print("ergodic_str2: ", string4[index])
# 3.5 删除
string5 = "像个顽皮的孩子"
del string5
# print("del_str: ", string5)
# 3.6 分割
# partition制定分隔符；split指定分隔符分割几回
string6 = "多么-好笑的-心事 TEST METHOD YOU LOSE"
partition_str = string6.partition("-")
print("partition_str: ", partition_str)
split_str = string6.split(" ", 2)
print("split_str: ", split_str)
# 3.7 替换
# 与替换相关的方法：replace、strip、lstrip、rstrip
string7 = " 顽皮的像个孩子的大人 "
replace_str = string7.replace('的', "XX", 2)
print("replace_str: ", replace_str)
strip_str = string7.strip()
print("strip_str去掉两边的空格:", strip_str)
lstrip_str = string7.lstrip()
print("lstrip_str去掉左边的空格:", lstrip_str)
rstrip_str = string7.rsplit()
print("rstrip_str去掉右边的空格：", rstrip_str)
# 3.8 链接
string8 = "MOREANDMORE"
join_str = '*'.join(string8)
print("join_str: ", join_str)
list8 = ['xi', 'as', 'peo']
join_list = "->".join(list8)
print("join_list: ", join_list)
# 3.9 大小写转换
# 第一个单词首字母大写：capitalize；所有字母小写：lower；所有字母大写：upper；单词首字母大写：title；大写转小写，小写转大写：swapcase
string9 = "start is More and More"
capitalize_str = string9.capitalize()
print("capitalize_str: ", capitalize_str)
lower_str = string9.lower()
print("lower_str: ", lower_str)
upper_str = string9.upper()
print("upper_str: ", upper_str)
tittle_str = string9.title()
print("tittle_str: ", tittle_str)
swapcase_str = string9.swapcase()
print("swapcase_str: ", swapcase_str)
# 3.10 判断字符串的内容
# isalnum字符串是数字或字母的组合；isalpha字符串所有是字母；isdigit字符串数字的组合
string11 = "Howare1213"
isalnum_str = string11.isalnum()
print("isalnum字符串是数字或字母的组合: ", isalnum_str)
isalpha_str = string11.isalpha()
print("isalpha字符串所有是字母：", isalpha_str)
isdigit_str = string11.isdigit()
print("isdigit字符串数字的组合：", isdigit_str)
# 3.11 判断以什么开头
string10 = "How are 你?"
startswith_str = string10.startswith("How")
print("startswith_str: ", startswith_str)
endswith_str = string10.endswith("?")
print("endswith_str: ", endswith_str)
# 3.12 格式化输出
string12 = "My name is {name}, I'am {age} years old."
print(string12.format(name="XIAO MI", age=9))
print(string12.format_map({"name": "MI", "age": 90}))
name = input("please input your name: ")
age = int(input("please input your age: "))
sex = bool(int(input("please input your sex: ")))
job = input("please input your job: ")
salary = input("please input your salary: ")
if sex == True:
sex = 'male'
else:
sex = 'fmale'
if salary.isdigit():
salary = int(salary)
else:
exit("salary must be int.")
print(name, age, sex, job, salary)
# 格式化输出字符串
personal_info = ''' -------------Personal information of %s--------- .........NAME: %s .........AGE: %d .........SEX: %s .........JOB: %s .........SALARY: %f .........WORK STILL: %d YEARS --------------This is the end------------- ''' % (name, name, age, sex, job, salary, (65-age))
print(personal_info)
# 3.13 扩展
string13 = "name\tage\tsex\nA\t22\tmale\nB\t23\tfmale"
expandtabs_str = string13.expandtabs()
print("expandtabs_str: \n", expandtabs_str)
复制代码
4. 列表（list）
列表是由一系列特定元素顺序排列的元素组成的，它的元素能够是由任何数据类型即数字、字符串、列表、元组、字典、布尔值等，同时其元素是能够修改的。【GitHub代码commits id：9a6357b】数据结构
（1）索引、切片
（2）追加
（3）拓展
（4）插入
（5）取出
（6）删除
（7）排序
复制代码
# （1）索引、切片
list41 = [123, 'string', [1, 2, 3], (1, 2), {"APP": "1"}, True]
index_list = list41[2]
print("index_list: ", index_list)
section_list = list41[0: 3]
print("section_list: ", section_list)
# （2）追加【append】----- 将元素总体添加
list42 = [123, 'string', [1, 2, 3], (1, 2)]
list42.append([1, 2])
print("append_list: ", list42)
# （3）拓展【extend】----- 将元素分解添加
list43 = [123, 'string', [1, 2, 3], (1, 3)]
list43.extend([1, 3])
print("append_list: ", list43)
# （4）插入【insert】
list44 = [1, 2, "ok", [20, 9]]
list44.insert(3, "R")
print("insert_list: ", list44)
# （5）取出【pop】
list45 = [23, "OOO", "pop"]
list45.pop()
print("pop_list: ", list45)
# （6）删除【remove、del】
list461 = ["1", 2, "ok", [20, 9]]
list462 = ["1", 2, "ok", [20, 9]]
list461.remove("1")
print("remove_list: ", list461)
del list462[0]
print("del_list: ", list462)
# （7）排序【sorted】
list47 = [11,55,88,66,35,42]
print("sorted_list: ", sorted(list47))
print("sorted_reverse_list: ", sorted(list47, reverse=True))
复制代码
5. 元组（tuple）
元组即为不可修改的列表，用圆括号标识，特性和list类似。【GitHub代码commits id：aa1a46a】app
tuple51 = (1, 2, [22, 3])
print("切片：", tuple51[0])
复制代码
6. 字典（dict）
字典为一系列的键-值对，每一个键值经过逗号分割，每一个键对应一个值，能够经过键来访问值。无序访问。 键的要求：必须是不可变的。能够是数字、字符串、元组、布尔值。编程语言
dict61 = {
('ok', ): 1,
"abc": "中文",
True: ['abc']
}
print("dict61: ", dict61)
# 遍历字典----键
for key in dict61:
print(key)
print(dict61.keys())
# 遍历字典----键值对
print(dict61.items())
# 遍历字典----值
print(dict61.values())
复制代码
7. 集合（set）
集合是一个无序不重复元素的集。set集合类须要的参数必须是迭代类型的，如：序列、字典等，而后转换为无序不重复的元素集。因为集合是不重复的，因此能够对字符串、列表、元组进行去重。post
集合的特性：
（1）去重
（2）无序
（3）每一个元素必须为不可变类型（hashable类型，可做为字典的key）
复制代码
set711 = {"ABC", 'abc', "test", "test", (12, 3), True}
set712 = set({"ABC", 'abc', "test", "test", (12, 3), True})
set713 = frozenset({"ABC", 'abc', "test", "test", (12, 3), True, "这是一个不可变的集合"})
# （2）增【add、update】
set721 = {'A', 'B', 'C'}
set721.add('D')
print("set_add: ", set721)
set722 = {'A', 'B', 'C'}
set722.update("ERT")
print("update_set: ", set722)
#（3）删除【pop、remove、discard】
set731 = {'A', 'B', 'C'}
set731.pop()
print("pop_set: ", set731)
set732 = {'A', 'B', 'C', 'D'}
set732.remove('C')
print('remove_set: ', set732)
set733 = {'A', 'B', 'C', 'DF'}
set733.discard('E') # 若是未找到该元素，则无视
print("discard_set: ", set733)
#（4）关系运算【交集&、并集|、差集-、交叉补集^、issubset、isupperset】
set741 = {'a', 'b', 'c', 'd', 1}
set742 = {'A', 'D', 'e', 'F', 1}
print("交集&", set741 & set742)
print("并集|", set741 | set742)
print("差集-", set741 - set742)
print("交叉补集^", set741 ^ set742)
print("issubset前是不是后的子集：", set741.issubset(set742))
print("isupperset前是不是后的父集：", set741.issuperset(set742))
复制代码
8. 栈（stack）
栈是一种后进先出(FILO)的数据结构，能够操做列表来实现栈的数据结构特性。删除的元素至关因而删掉了栈尾的元素。【GitHub代码commits id：426eb81】学习
class Stack():
def __init__(self, size):
self.stack131 = []
self.top = -1
self.size = size
def isfull(self):
return self.top + 1 == self.size
def isempty(self):
return self.top == '-1'
# 入栈前先检查栈是否已满
def push_stack(self, x):
if self.isfull():
raise Exception("statck is full")
else:
self.stack131.append(x)
self.top = self.top + 1
# 出栈以前检查栈是否为空
def pop_statck(self):
if self.isempty():
raise Exception("stack is empty")
else:
self.top = self.top - 1
self.stack131.pop()
def show_stack(self):
print(self.stack131)
if __name__ == "__main__":
s = Stack(10)
s.show_stack()
for i in range(6):
s.push_stack(i)
s.show_stack()
for i in range(3):
s.pop_statck()
s.show_stack()
print("stack FILO is end.......")
复制代码
9. 队列（queue）
队列是一种后进先出(FIFO)的数据结构，能够操做列表来实现栈的数据结构特性。新增的元素是添加的队列结尾的元素，出队列的元素至关因而删掉了对列前面的元素。【GitHub代码commits id：6367333】
class Queue():
def __init__(self, size):
self.queue132 = []
self.front = -1
self.rear = -1
self.size = size
def isfull(self):
return self.rear - self.front + 1 == self.size
def isempty(self):
return self.front == self.rear
# 入队列
def enqueue(self, x):
if self.isfull():
raise Exception("queue is full")
else:
self.queue132.append(x)
self.rear = self.rear + 1
# 出队列
def dequeue(self):
if self.isempty():
raise Exception("queue is empty")
else:
self.queue132.pop(0)
self.front = self.front + 1
def show_queue(self):
print(self.queue132)
if __name__ == "__main__":
s = Stack(10)
s.show_stack()
for i in range(6):
s.push_stack(i)
s.show_stack()
for i in range(3):
s.pop_statck()
s.show_stack()
print("stack FILO is end.......")
q = Queue(7)
q.show_queue()
for i in range(6):
q.enqueue(i)
q.show_queue()
for i in range(3):
q.dequeue()
q.show_queue()
复制代码
3、语法结构
1. 选择结构
序结构就是按照你写的代码顺序执行，也就是一条一条语句顺序执行。
分支结构又称为选择结构，是程序代码根据判断条件选择执行特定的代码。
若是条件为真，程序执行一部分代码；不然执行另外一部分代码
基本语法：
一、if
二、if...else
三、if...elif...else
四、if...elif...elif......else
五、if 嵌套
复制代码
# 1.if
a = 1
if a == 1:
print("你的输出正确")
# 2.if...else...
a = 1
if a == 1:
print("a的值为1")
else:
print("a的值不为1")
# 3.if...elif...else...
a = 1
if a > 1:
print("a的值大于1")
elif a == 1:
print("a的值等于1")
else:
print("a的值小于1")
# 4.if...elif...elif......else
a = 1
if a == 1:
print("a的值为1")
elif a == 2:
print("a的值为2")
elif a == 3:
print("a的值为3")
else:
print("a的值为不知道是什么")
# 5.if 嵌套
a = 1
b = 2
if a == 1:
if b == 2:
print("b的值为1")
else:
print("b的值不知道是什么")
else:
print("a的值迷失了~")
复制代码
2. 循环结构
循环结构是指知足必定的条件下，重复执行某段代码的一种编码结构。
Python的循环结构中，常见的循环结构是for循环和while循环。
for 循环常常用与遍历字符串、列表、字典等数据结构，for循环须要知道循环次数。
复制代码
# 1. for...in...
list1 = [1, 2, 3, 4, 5, 2, 4, 7, 9, 0]
count = 0
for i in list1:
if i == 2:
count += 1
print("count: ", count)
# 2.嵌套for循环
# 乘法表
result = 0
for i in range(1, 10):
for j in range(1, i + 1):
print(str(j) + '*' + str(i) + '=' + str(i*j) + '', end=' ')
print(' ')
# 3.while循环
num = 1
while num <= 5:
print("num：", num)
num += 1
复制代码
四 文件操做
读写文件是最多见的IO操做，现代操做系统不容许普通程序直接操做磁盘，读写文件就是请求操做系统打开一个文件操做对象，经过操做系统提供的接口进行对文件的读写操做。
1. 读文件
读取文件的三个必要步骤：
（1）以读文件的模式 read 打开一个文件对象；
（2）read() 方法读取文件中的内容；
（3）文件读取操做完后，要进行文件的关闭。由于文件对象会占用操做系统资源。
复制代码
# codecs模块：主要用来解决文件乱码的问题
import codecs
f_read = codecs.open('read_file.txt', 'rb', encoding="utf-8")
print("f_read: ", f_read.read())
f_read.close()
复制代码
2. 写文件
f_write = codecs.open('write_file.txt', 'wb', encoding='utf-8')
f_write.write("********************\n")
f_write.write("<鹅>\n")
f_write.write("曲项向天歌\n")
f_write.write("白毛浮绿水\n")
f_write.close()
复制代码
3. 文件操做经常使用方法
# 3.1 readlines()：用于读取全部行(直到结束符 EOF)并返回列表，该列表能够由 Python 的 for... in ... 结构进行处理。
f_readlines = codecs.open('write_file.txt', 'rb', encoding='utf-8')
text_list = f_readlines.readlines()
print('text_list_type: ', type(text_list))
print("text_list: ", text_list)
print(text_list[2])
f_readlines.close()
# 3.2 readline()：用于从文件读取整行，包括 "\n" 字符。若是指定了一个非负数的参数，则返回指定大小的字节数，包括 "\n" 字符。
# __next__()：返回迭代器的下一个指向
f_readline = codecs.open('read_file.txt', 'rb', encoding='utf-8')
readline_list = f_readline.readline()
print('readline_list_type: ', type(readline_list))
print("readline_list: ", readline_list)
print(f_readline.__next__())
print(f_readline.__next__())
f_readline.close()
# 3.3 writelines()：用于向文件中写入一序列的字符串。
f_writelines = codecs.open("writelines_file.txt", 'wb', encoding='utf-8')
write_list = f_writelines.write("1213311\nnewbanlance\n\n")
writelines_list = f_writelines.writelines(["11111111\n", '2222222\n', '333333333\n'])
f_writelines.close()
# 3.4 tell()：返回文件的当前位置，即文件指针当前位置。
f_tell = codecs.open('tell_file.txt', 'wb', encoding='utf-8')
f_tell.write("1213311\nnewbanlance\n\n")
print(f_tell.tell())
f_tell.writelines(["11111111\n", '2222222\n', '333333333\n'])
print(f_tell.tell())
f_tell.close()
# 3.5 seek()：用于移动文件读取指针到指定位置
f_seek = codecs.open('seek_file.txt', 'wb', encoding='utf-8')
f_seek.write("abcdefgh\n12131313\n\djkfdjskfjkd\n")
print(f_seek.tell())
f_seek.seek(0)
f_seek.writelines(["11111111\n", '2222222\n', '333333333\n'])
f_seek.close()
# 3.6 name(): 读取文件名
f_name = codecs.open('name_file.txt', 'wb', encoding='utf-8')
print("f_name： ", f_name.name)
print("f_name_closed", f_name.closed)
# 3.7 flush(): 刷新缓冲区的，即将缓冲区中的数据马上写入文件，同时清空缓冲区，不须要是被动的等待输出缓冲区写入。通常状况下，文件关闭后会自动刷新缓冲区，
# 但有时你须要在关闭前刷新它，这时就可使用 flush() 方法。
复制代码
4. 文件操做的上下文管理
文件操做中常常会忘记文件的关闭操做，使用with操做会避免这一状况的发生。 【GitHub代码commits id：ecf390d】
with codecs.open('with_file.txt', 'wb', encoding='utf-8') as f_with:
f_with.write("test with.")
print("f_with_closed: ", f_with.closed)
print("f_with_closed: ", f_with.closed)
复制代码