[Python知识库]python基础入门（Peak带你学python)

Peak带你学python

基础语法知识

print函数

python里面的输出函数，可以输出数字、字符串、以及含有运算符的表达式，可以将内容输出到显示器或者文件

#输出到显示器
print(500)
print(98.5)
print('500')
print('我会python输出啦')
print('aa','abc') #不换行输出
print(3+1)
#输出到文件
fp = open('D:/text.txt','a+') #a表示以读写的方式打开文件，+表示可以追加不清除原有的
print('我python可以在文件里面写东西了',file=fp) #注意一下file
fp.close()

转义字符

大家应该都知道，前面加一个’‘就好了。例如’\’，例如’\n’换行、’\t’制表符、’\b’退格
ps: r或者R可以让转义字符失效，最后一个字符不可以是 ''

print('我爱你\n逗你玩呢')
print(r'我爱你\n你猜我是不是真的')

进制转换

• bin：转换为二进制
• oct：转换为八进制
• ord：字符转换为十进制，与char作用相反
• hex：转换为十六进制

ps:利用input()函数读入的时候，默认是字符串格式，需要用int格式转换为十进制数

#int使用情况
n = input() #输入1234
int(n,10) #输入1234认为是十进制数转换为1234
int(n,8)  #输入1234认为是八进制数转换为668
int(n,16)  #输入1234认为是八进制数转换为4460
int(n,2)  #输入1111认为是八进制数转换为15

bin(10) #0b1010
oct(10) #0o12
hex(10) #0xa
ord('a') #97

保留字和标识符

下面的运行可输出保留字

import keyword
print(keyword.klist)

标识符的命名规则: 以字母、数字、下滑线组成；不能以数字开头； 不能使用保留字； 区分大小写

变量

变量由三部分组成：标识、类型和值。其中标识可以认为就是C语言或者其他语言的地址可以通过id(变量名)函数获得，类型也就是所谓的整型、浮点型之类的，可以通过type(变量名)来获得

name = '我爱python'	#name就是变量
print(id(name)) #输出标识
print(type(name)) #输出类型
print(name) #输出值

数据类型

• 整数类型(int)：正整数、0、负整数、二进制整数、八进制整数、十进制整数、十六进制整数都可以。
• 浮点数类型(float)：浮点数进行运算的时候可能出现小数位数不确定

print(1.1+1.2) #2.3
print(1.1+2.1) #3.2
print(1.1+2.2) #3.3000000000000003
# 解决方法
导入模块decimal		
from decimal import Decimal
print((Decimal('1.1')+Decimal('2.2')))	# 3.3								

• 布尔类型(bool)：表示真或者假，True or Talse,可以转换为整数型 1 和 0

print(True) #Ture
print(False) #False
print(True+1) #2
print(False+1) #1

• 字符串类型(str)：不可改变的字符序列，类似C语言的const char*
  其中，可以用单引号、双引号、和三引号表示，单引号和双引号的字符串必须在一行，三引号可以连续分布多行。所以有时也可以用三引号来书写注释

str1='生活不易，小白叹气'
str2="生活不易，小白叹气"
str3=""""生活不易
    小白叹气"""
str4=''''生活不易
    小白叹气'''
print(str1)
print(str2)
print(str3)
print(str4)

数据类型转换

一般在不同数据类型进行拼接的时候，会用到数据类型转换。也就是一般用于解决TypeError: can only concatenate str (not "int") to str这种报错

• str()：将其他数据类型转换为字符串类型
• int()：将其他数据类型转换为整数类型，注意文字类和小数类字符无法转换，也就是只能是整数的字符串才可以。浮点类型转换为整数类型，抹零处理
• float()：将其他数据类型转换为浮点数，注意文字类无法转换为小数，整数转换为小数时，结尾加上 .0

注释

python里面只有单行注释以#号开头，第一行的注释可以用来声明中文编码格式，比如utf-8,gb2312,gbk之类的。如果非要使用多行注释的话，可以使用三引号来表示。

input函数

• input函数：是一个输入函数，其中里面可以写提示语。

n = input("这里是提示")

注意返回的类型是str类型，看自己需求进行转换。

#来一个小demo
a = int(input("请输入第一个整数："))
b = int(input("请输入第二个整数："))
print("两个数的和为:",a+b)

运算符

• 算术运算符：+（加）、-（减）、*（乘）、/（除）、//（整除）、%（取余）、**（幂运算）
• 赋值运算发：从右向左赋值。
  • 支持链式赋值：a = b =c
  • 支持参数赋值：+=、-=、*=、/=、//=、%=
  • 支持系列解包赋值：a,b,c = 1,2,3；a,b = b,a（相当于a与b进行交换）
• 比较运算符：>、<、<=、>=、!=、==都是对值的比较，比较id用is 和 is not
  ps：返回值是布尔类型
• 布尔运算符：and、or、not、in、not in
  ps: in 和 not in在字符串、列表、字典中较为好用
• 位运算符：&（按位与）、|（按位或）、<<（左移，对于整数*2）、>>（右移，对于整数相当于//2）
  4&8 结果为0，因为4对应00000100，8对应00001000。按位与为00000000，所以为0

运算符优先级

算术运算符>位运算符>比较运算符>布尔运算符>赋值运算符

布尔值

可通过内置函数bool()获得

• False：False、数值0、None、空字符串、空列表、空元组、空字典、空集合
• True：其他的都是True
  

if~else选择结构

• if 条件表达式:
  条件执行体

条件表达式为真则执行条件执行体

#哈哈哈哈，莫名想起武汉三行情书大赛
#螃蟹在剥我的壳，笔记本在写我。漫天的我落在枫叶上雪花上。而你在想我。
if 1+1!=2:
    print("你爱我")

• if 条件表达式:
  ???? 条件执行体1
  else:
  ????条件执行体2
  条件表达式为真，执行条件执行体1，否则执行条件执行体2

n = int(input("请输入一个正整数："))
if n%2==0:
    print(n," 是偶数")
else:
    print(n," 是奇数")

• if 条件表达式:
  ???? 条件执行体1
  elif:
  ???? 条件执行体2
  elif:
  ???? 条件执行体3
  …
  elif:
  ???? 条件执行体N
  [else:]

与上面类似，自己琢磨一下吧，小机灵鬼

pass语句

相当于C语言的空语句 ; 或者 汇编语言的 nop。不知道写什么代码，可以先用pass代替

range()函数

• 可以生成一个整数序列，返回值是一个迭代器对象，优点是所有的range占用的空间都是相同的
• 三种用法：
  • range(stop)：[0, stop), 每次加一
  • range(start, stop)：[start, stop),每次加一
  • range(stast, stop, step)：[start, stop),每次加step

r = range(10)
print(list(r))
r = range(2,10)
print(list(r))
r = range(2, 10, 2)
print(list(r))

可以用in 或者 not in 查看数字是否在迭代器里面

循环结构

while循环

• while 条件表达式：
  ???? 条件执行体（循环体）

表达式为True的时候执行循环体，直到表达式为False结束循环

n = 0
while n < 10:
    print(n)
    n+=1

for-in循环

• for 自定义的变量 in 可迭代对象:
  ???? 循环体

自定义变量会依次取出可迭代对象的内容，不需要自定义变量的时候可以将自定义变量替换为下滑线

for item in '啦啦啦啦':
    print(item)

for i in range(9):
    print(i)
    
for _ in range(3):
    print("重要的事情说三遍")

break语句

• 退出上一级循环

a = 0
while a < 3:
    pwd = input("请输入密码：")
    if pwd == '8888':
        print("密码输入正确")
        break
    else:
        print("密码输入错误")
        a += 1

continue语句

• 用于结束当前循环进入下一循环, 一般配合if语句
  

else语句

if~else语句

这个语句上面有就不详细说明了

while ~ else和for ~ else

如果循环体执行完毕没有碰到break则执行。和C语言中swith~case语句中的，default语句有点像。

a = 0
while a < 3:
    pwd = input("请输入密码：")
    if pwd == '8888':
        print("密码输入正确")
        break
    else:
        print("密码输入错误")
        a += 1
else:
    print("三次输入错误")

for i in range(3):
    pwd = input("请输入密码：")
    if pwd == '8888':
        print("密码输入正确")
        break
    else:
        print("密码输入错误")
else:
    print("三次输入错误")

嵌套循环

• 99乘法表

for i in range(1,10):
    for j in range(1, i + 1):
        print(i, '*', j, '=', i*j, end='\t')
    print('')

列表

相当于其他类型的数组，不过比数组更加方便可以存储不同的类型。
特点：1. 元素按照顺序有序排列  2. 索引映射唯一的数据  3. 可以存储重复数据
			4. 任意数据类型混存  5. 根据需要动态分配内存和回收内存

列表的创建与删除

• 创建
  • 使用中括号[]

    lis = [123,'11',12.3]
    

  • 使用内置函数list()

    lis = list([123,'11',12.3])
    

列表的查询操作

• 获取指定元素的索引通过 index() 来实现。但是只能获取第一个，不存在则会报错。

  lis = list(['11','11',12.3])
  print(lis.index('11'))
  #也可以指定索引范围查找
  print(lis.index('11', 1, 3)) #索引范围[1, 3)
  

• 获取列表的单个元素，通过指定的索引获得
  

  lis = list(['11','22',12.3])
  print(lis[0])
  print(lis[1])
  print(lis[2])
  print(lis[-1])
  print(lis[-2])
  print(lis[-3])
  

• 获取多个元素，通过切片操作
  

  lst = [10, 20 ,30, 40, 50, 60, 70, 80]
  print(lst[1:6:1])
  print(lst[1:6:2])
  print(lst[0:6:1])
  print(lst[0:6:2])
  print(lst[-1:1:-1])
  print(lst[-1:-7:-1])
  

  
• 判断指定元素在列表中是否存在
  元素 in 列表名 或者 元素 not in 列表名

列表元素的遍历

for 迭代变量 in 列表名:
	对应的操作

列表元素的增删改操作

• 增：
  • append()在列表的末尾添加一个元素
  • extend()在列表的末尾至少添加一个元素
  • insert()在列表的任意位置添加一个元素
  • 切片

  lst = ["武汉三行情书大赛"]
  lst.append("螃蟹在剥我的壳，笔记本在写我。")
  lst.extend(["漫天的我落在枫叶上雪花上。", "而你在想我。"])
  for item in lst:
     print(item)
  lst1 = [11,22,33,44,55]
  lst1.insert(3,77)
  print(lst1)
  lst1[2:] = lst
  print(lst1)
  

• 删
  • remove()删除指定元素，有重复元素删除第一个。没有则报错。
  • pop()删除指定索引的元素，索引超出范围则报错（默认是最后一个）
  • clear()清空列表
  • del()删除列表

  lst = [10,20,30,40,50,60,70,80,90]
  print(lst)
  lst.remove(80)
  print(lst)
  lst.pop(4)
  print(lst)
  lst.pop()
  print(lst)
  lst.clear()
  print(lst)
  del(lst) #或者del lst
  

• 改：
  • 利用索引修改
  • 利用切片修改

  lst = [10,20,30,40,50,60,70,80,90]
  print(lst)
  lst[2] = 100
  print(lst)
  lst[5:8] = [11,22,33,44,55,66,88]
  print(lst)
  

列表元素的排序

• sort()方法：默认升序，利用reverse = True可以实现逆序
• sorted()方法：默认升序，利用reverse = True可以实现逆序，不改变原列表，产生新的列表对象

lst = [10,20,70,80,90,30,40,50,60]
print(lst)
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)

new_lst = sorted(lst)
print(new_lst)

列表生成式

lst = [i for i in range(10)]
print(lst)

字典

• python的内置数据结构之一，是一个可变序列
• 以键值对的方式储存数据，是一个无序的不可变序列
• 利用hash散列表的方式来储存

字典的创建

• 常用的创建方式大括号

• 使用内置函数dict()

  scores = {'张三': 100, '李四':20,'王五':60}
  print(scores)
  print(type(scores))
  student=dict(name='张三',age = 100)
  print(student)
  print(type(student))
  

字典元素的获取

区别是，[]获取如果没有会报错，get()则会返回None

scores = {'张三': 100, '李四':20,'王五':60}
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))
values = scores.values()
print(values)
print(type(values))
print(list(values))
items = scores.items()
print(items)
print(type(items))
print(list(items))

字典的增、删、改操作

scores = {'张三': 100, '李四':20,'王五':60}
print('张三' in scores)
print('陈六' in scores)
del scores['张三']
print(scores)
scores.clear()
print(scores)
scores['陈六'] = 90
print(scores)
scores['陈六'] = 100
print(scores)

字典元素的遍历

scores = {'张三': 100, '李四':20,'王五':60}
for item in scores:
    print(item, scores.get(item))

字典的特点

字典生成式

• 内置函数zip()

  items = ['fruits', 'books', 'things', 'others']
  prices = [11,22,33,44]
  dict = {items:prices for items, prices in zip(items,prices)}
  print(dict)
  

元组

• python的内置数据结构之一，是一个不可变序列
• 不可变序列没有增删改操作，例如：元组、字符串。可变序列可以对序列执行增删改操作，但是对象地址不改变，例如：列表、字典

元组的创建方式

• 小括号直接创建,小括号可以省略
• 用内置函数tuple管理

  t = ('张三','李四','王五')
  print(t)
  print(type(t))
  t1 = tuple(('陈六','赵七'))
  print(t1)
  print(type(t1))
  

t = (90, [20,30],10)
#t[0]=100 报错
t[1].append(100) #不报错
print(t)

元组的遍历

• 利用for in循环来遍历，因为元组也是一种迭代对象

t = (90, [20,30],10)
for item in t:
    print(item)

集合

• 相当于没有 value 的字典，同样是使用hash函数散列表的储存方式，用空间换时间的思想

集合的创建方式

• {}
• 使用内置函数set()

p = {'hello', 'a', 90}
print(p)
s = set(range(6))
print(s)
#注意一下哦是无序的
print(set([3,4,5,6,7])) #比如你将3,4,5,6,7顺序换一下也是一样的，因为hash在散列表的位置是一样的
print(set((3,4,5,6,7)))
print(set('Y_peak')) 
print(set({3,4,5,6,7}))
print(set())

print(set((1,2,4,4,5,65)))#这个也是无序的，知道是无序储存就好

集合的相关操作

• 集合元素的判断操作

  • in or not in

  s = {10,20,30,40}
  print(10 in s)
  print(11 in s)
  print(11 not in s)
  

• 集合元素的新增操作

  • 调用add()方法，一次添加一个元素
  • 调用update()方法至少添加一个元素

  s = {10,20,30,40}
  print(s)
  s.add(80)
  print(s)
  s.update([12,14,89])
  print(s)
  s.update((33,88,19))
  print(s)
  

• 集合元素的删除

  • 调用remove()方法，一次删除一个指定元素。没有则报错
  • 调用discard()方法，一次删除一个指定元素，不会报错
  • 调用pop()方法，删除任意一个元素
  • 调用clear()方法，清空集合

  s = set(range(11))
  s.remove(10)
  print(s)
  s.pop()
  print(s)
  s.clear()
  

• 集合间的关系
  

集合的数学操作

• 交集

  s1 = {10,20,30,40}
  s2 = {30,20,90,80}
  print(s1.intersection(s2))
  print(s1 & s2)
  

• 并集

  s1 = {10,20,30,40}
  s2 = {30,20,90,80}
  print(s1.union(s2))
  print(s1 | s2)
  

• 差集

  s1 = {10,20,30,40}
  s2 = {30,20,90,80}
  print(s1.difference(s2))
  print(s1 - s2)
  

• 对称差集

  s1 = {10,20,30,40}
  s2 = {30,20,90,80}
  print(s1.symmetric_difference(s2))
  print((s1 - s2)|(s2-s1))
  print(s1^s2)
  

集合生成式

列表、字典、元组、集合小结

print({i *i for i in range(1,9)})

字符串

字符串的驻留机制

• 字符串是不可变序列
  
  

pycharm对字符串有优化，相同的字符串基本都是一个对象

字符串的查找

• index()：查找子串substr第一次出现的位置，如果子串不存在则，抛出异常valueError
• rindex()：查找子串substr最后一次出现的位置，如果子串不存在则，抛出异常valueError
• find()：查找子串substr第一次出现的位置，如果子串不存在则，返回-1
• rfind：查找子串substr最后一次出现的位置，如果子串不存在则，返回-1
  ps:推荐使用后两种

str = 'hello world lo‘'
print(str.index('lo'))
print(str.find('lo'))
print(str.rindex('lo'))
print(str.rfind('lo'))
print(str.find('k'))

字符串大小写的转换

• upper()：将所有字符转换为大写

• lower()：将所有字符转换为小写

• swapcase()：将所有字符大小写互换，即大写字符改为小写，小写字符改为大写字符

• capitalize()：将第一个字符转换为大写，其余字符转换为小写

• title()：把每个单词的第一个字符转换为大写，其余转换为小写

  str = 'Hello WoRld'
  print(str.upper())
  print(str.lower())
  print(str.swapcase())
  print(str.capitalize())
  print(str.title())
  

  

字符串内容对齐的方法

str = 'Hello World'
print(str.center(30,'-'))
print(str.ljust(30,'*'))
print(str.rjust(30,'#'))
print(str.zfill(30))
print('-90'.zfill(10))

字符串分割操作

str = 'Hello World'
print(str.split())
print(str.split(sep='l'))
print(str.split('l'))
print(str.split('l',1))
print(str.split(sep='l',maxsplit=1))

print(str.rsplit())
print(str.rsplit(sep='l'))
print(str.rsplit('l'))
print(str.rsplit('l',1))
print(str.rsplit(sep='l',maxsplit=1))

判断字符串操作

字符串的替换与合并

str = 'Hello a a a aaaa'
print(str.replace('a','b'))
print(str.replace('a','b', 3))
lst = ['hello','world','lallall'] #元组集合同样可以
print(''.join(lst))
print('|'.join(lst))

字符串的比较

print('apple'>'app')
print('java'>'python')
print('java'>'Python')

ps：注意区分 == 和 is 前者比较的是值是否相等， is比较的是id是否相等，也就是内存地址是否想等

字符串的切片操作

s = 'hello,peak.'
s1 = s[:5]
s2 = s[6:]
print(s,s1,s2)

格式化字符串

name = '妞妞'
age = 18
a = '%s 永远 %d 岁'% (name, age)
print(a)
b = '{0} 永远 {1} 岁'.format(name,age)
print(b)
c = '{Name} 永远 {Age} 岁'.format(Name = name,Age = age)
print(c)

# ptyhon3 才可以使用的 f-string方法
d = f'{name} 永远 {age} 岁'
print(d)

注意：%的用法也可以设置宽度，正数左对齐，负数右对齐，对浮点数小数点后面表示保留几位小数，{也可以不过要使用:}

print('你占多宽啊')
print('01234567890123456789')
a = '|%3d|%-7.2f|' % (12,12.3456)
print(a)

b = '|{0:3}|{1:7.3f}|'.format(12,3.1415926)
print(b)

字符串的编码与解码（补充）

数据在进行传输的时候会进行编码转换为二进制进行传输，然后接受到后进行解码，不同的编码方式与解码方式是不同的。可以通过下列的encode和decode进行编码和解码

s = '英雄不问出处'
print(s.encode(encoding="GB2312"))
b = s.encode(encoding="GB2312")
print(b.decode(encoding="gb2312"))

函数

简化编程过程，实现代码复用，隐藏实现的细节，提高可维护性

函数的创建、调用以及参数传递

函数的创建格式一般如下：

def 函数名([输入参数]):
	函数体;
	[return xxx;]

首先进行函数的定义，当到函数执行的时候会将对应的参数传入，也就是下面的第一次 把 1 赋值给 a，2 赋值给 b； 第二次将 ‘11’ 赋值给 a，把 ‘22’ 赋值给 b。然后跳转到函数进行执行，return 是返回的结果。其中a , b我们称为形式参数， 11、22，‘11’、'22’称为实际参数可以多次调用多次执行。

def calc(a,b):     #函数定义的地方
    c = a+b;
    return  c

result = calc(1,2) #函数第一次执行的地方
print(result)

str = calc('11','22') #函数第二次执行的地方 a='11', b='22'
print(str)

str1 = calc(b='11', a='22') #关键字传值，按照关键字对应， b='11', a='22'
print(str1)

python的函数调用需要注意的是如果实际参数的可变对象则会改变实际参数，如果为不可变对象则不会改变实际参数。

函数的返回值

当返回值为多个时，返回的为元组

def func(num):
    odd=[] #存奇数
    even=[] #存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
print(func([10,31,29,43,55,12,89,88,77]))

函数定义默认参数

• 函数定义时，给形参设置默认值，只有与默认值不符合的时候才需要传递实参

def func(a, b=10):
    return a+b;

print(func(20)) #默认b为10
print(func(20,30))

函数参数之个数可变的位置参数和关键字参数

 主要用于不知道需要传递几个参数时

• 个数可变的位置参数，加上一个 * 最终形参会形成一个元组

def func(*args):
    print(args)
func(10)
func(10,20)
func(10,20,30)
func(10,20,30,40)

• 定义函数时，无法事先传递的关键字实参的个数使用可变关键字参数, 参数前加上 **

def func(**args):
    print(args)
func(a = 10)
func(a = 10,b = 20)
func(a = 10,b = 20,c = 30)
func(a = 10,b = 20,c = 30,d = 40)

PS：在一个函数的定义参数的时候只能有一个可变的参数（位置参数或者关键字参数）

• 函数定义及调用的总结
  

def func(a, b, *, c, d): # * 后面必须使用关键字实参，不然会报错
    print(a,b,c, d,sep=" | ")
func(10, 20, c=30, d=40)

def func(a, b, c):
    print(a,b,c,sep=" | ")

list=[11,22,33]
func(*list)

变量的作用域