Python3小白基础入门 | 学习笔记

一、输入输出

1、读入字符串

str=input()
print(str)

2、读入整数数字

a=int(input())
print(a)
print(type(a))#type()输出变量类型

3、格式化输出

+直接拼接：

name = "Li hua"
age = 24
print("Hello "+name+", you are " + str(age) + " years old")

%：

name = "Li hua"
age = 24
print("Hello %s, you are %d years old"%(name,age))

format：

name = "Li hua"
age = 24
print("Hello {}, you are {} years old".format(name,age))

前缀f表达式：

name = "Li hua"
age = 24
print(f"Hello {name}, you are {age} years old")

注：print自带的end

print('ABC')
print('DEF')

输出为：
ABC
DEF

print('ABC',end ='') %这里的end中没有东西
print('DEF')

则结果为：ABCDEF
因为end的作用就是告诉print，将print自带的换行用end中指定的str代替

print('ABC',end =' ')
print('DEF')

输出结果为：ABC DEF

4、小数控制位数输出

有的时候需要控制python中的浮点数输出的位数，一般有三种方法：
① 使用round函数，用法为：round( x [， n] )，x为浮点数，n为保留的小数位数参数是可选的如果不写那么默认不保留小数。
② 利用"%.nf"输出n位小数
③ 使用format函数格式化数字输出，format函数中使用一个大括号表示需要填充的参数，：后面可以规定数字的精度与类型

#
print(round(float(input()),2))

#
a=float(input())
print('%.2f'%a)

#
print("{:.2f}".format(float(input())))

5、map映射输入

map() 会根据提供的函数对指定序列做映射。

x1, y1 = map(int, input().split()) # 1.输入第一行两个数字
x2, y2 = map(int, input().split())  # 1.输入第二行两个数字

二、类型转换

1、小数化整数

#强制类型转换
a=input()
print(int(float(a)))

2、为整数增加小数点

#使用强制类型转换为输入的整数增加小数点，并输出改变类型后的变量类型
a=float(input())
print(('%.1f'%a))
print(type(a))

3、十六进制转十进制

Python进制转换：Python内置函数进行进制转换的原理是将读入的一个字符串(python默认读入的都是字符串形式)转为10进制，然后再用相关函数进行其他进制转换

八/十/十六进制转二进制：bin(int(n,8))、bin(int(n,10))、bin(int(n,16))

二/十/十六进制转八进制：oct(int(n,2))、oct(int(n,10))、oct(int(n,16))

二/八/十六进制转十进制：int(n,2)、int(n,8)、int(n,16)

二/八/十进制转十六进制：hex(int(n,2))、hex(int(n,8))、hex(int(n,10))

#读入一个十六进制数字转为十进制
a=input()
b=int(a,16)
print(b)

三、字符串

1、字符串拼接

#直接用+实现字符串拼接
a=input()
b=input()
print(a+b)

2、计算字符串长度

#len()计算字符串的长度
a=input()
print(len(a))

3、字符串大小写问题

#lower()全小写，upper()全大写，title()首字母大写
a=input()
print(a.lower())
print(a.upper())
print(a.title())

4、去掉字符串两边的空白符（如空格或'\t'等）

a=input()
print(a.strip())

5、不用循环语句的字符串重复输出

#将字符串重复输出100遍
a=input()
print(a*100)

6、字符串截取字符

strname[start : end : step]

对各个部分的说明：

• strname：要截取的字符串；
• start：表示要截取的第一个字符所在的索引（截取时包含该字符）。如果不指定，默认为 0，也就是从字符串的开头截取；
• end：表示要截取的最后一个字符所在的索引（截取时不包含该字符）。如果不指定，默认为字符串的长度；
• step：指的是从 start 索引处的字符开始，每 step 个距离获取一个字符，直至 end 索引出的字符。step 默认值为 1，当省略该值时，最后一个冒号也可以省略。

#截取字符串前10个字符
a=input()
print(a[:10])

四、列表

Python列表的元素类型可以不同，列表是动态的，长度可以改变，可以随意增加，修改或删除元素。

1、列表创建、读取

某公司在面试结束后，创建了一个依次包含字符串 'Allen' 和 'Tom' 的列表offer_list，作为通过面试的名单。

请你依次对列表中的名字发送类似 'Allen, you have passed our interview and will soon become a member of our company.' 的句子。

但由于Tom有了其他的选择，没有确认这个offer，HR选择了正好能够确认这个offer的Andy，所以请把列表offer_list中 'Tom' 的名字换成 'Andy' ，

再依次发送类似 'Andy, welcome to join us!' 的句子。

offer_list=['Allen','Tom']
for i in offer_list:
    print('{}, you have passed our interview and will soon become a member of our company.'.format(i))

offer_list[1]='Andy'
for j in offer_list:
    print('{}, welcome to join us!'.format(j))

输入一行数字，构建列表

x, y, z = list(map(int, input().split()))

x = input().split()
a=[]
for i in x :
    a.append(int(i))

2、反转列表

reverse()函数用于反转列表

num=[3, 5, 9, 0, 1, 9, 0, 3]
num.reverse()
print(num)

3、列表添加

append() 函数可以向列表末尾添加任意类型元素

name = ['Niumei', 'YOLO', 'Niu Ke Le', 'Mona']
food = ['pizza', 'fish', 'potato', 'beef']
number = [3, 6, 0, 3]
friends=[]
friends.append(name)
friends.append(food)
friends.append(number)
print(friends)

4、列表元素弹出

pop()函数用于删除并返回列表中的一个元素（默认为最后一个元素）

stack = [1, 2, 3, 4, 5]
stack.pop()
print(stack)

#加上索引，可以弹出其余位置的元素
queue = [1, 2, 3, 4, 5]
queue.pop(0)
print(queue)

5、列表切片

切片是Python序列的重要操作之一，适用于列表、元组、字符串、range对象等，可以用切片截取列表中任何部分来获得一个新的列表，也可以进行元素的增、删、改

list = [3, 4, 6, 7, 2, 10, 16]
print(list[:])  # 取全部元素
print(list[0:])  # 取全部元素

print(list[:-1])  # 取 除最后一个元素外的所有元素

print(list[2:5])  # 取序号为2、3、4的元素，不包含最后一个序号的元素

print(list[::2])  # 从0开始隔一个取一个元素,步长为2

print(list[1:5:2])  # 从1开始，每隔一个取一个元素，步长为2，直到5为止

print(list[::-1])  # 从右向左取全部成员，步长-1

print(list[5:0:-2])  # 从右向左隔一个取一个元素，步长-2，不包含0

也可以通过slice()方法进行切片

slice(start, stop, step)

6、判断元素是否存在列表中

current_users=['Niuniu','Niumei','GurR','LOLO']
a="LOLO"
if a in current_users:
    print("old")
else:
    print("new")

7、列表元素类型转换

age=input().split(' ')#age列表元素为str类型

#将age列表元素类型转换为int型
age1=list(map(int,age))

#将age列表元素类型转换为float型
age1=list(map(float,age))

#列表元素整型（浮点型）变为str型
a = [1,2,3,4,5]
res = list(map(str,a))

8、列表解析式

类似于 [i for i in range(1,10)] 的表达式，这种表达式称为列表解析（List Comprehensions），类似的还有字典解析、集合解析等等。

列表解析式是将一个列表（实际上适用于任何可迭代对象）转换成另一个列表的工具。在转换过程中，可以指定元素必须符合一定的条件，才能添加至新的列表中，这样每个元素都可以按需要进行转换。

每个列表解析式都可以重写为 for 循环，但不是每个 for 循环都能重写为列表解析式，列表解析比 for 更精简，运行更快。

基本语法：[expression for iter_val in iterable (if cond_expr)]

list=[[1,2,3],[4,5,6],[7,8,9]]
n=int(input())
res=[]
for i in list:
    i=[j*n for j in i]
    res.append(i)
print(res)

五、运算符

1、算数运算符

运算符	描述
+	两个数相加，或是字符串连接
-	两个数相减
*	两个数相乘，或是返回一个重复若干次的字符串
/	两个数相除，结果为浮点数（小数）
//	两个数相除，结果为向下取整的整数
%	取模，返回两个数相除的余数
**	幂运算，返回乘方结果

2、比较（关系）运算符

运算符	描述
==	比较两个对象是否相等
！=	比较两个对象是否不相等
>	比较前者是否大于后者
<	比较前者是否小于后者
>=	比较前者是否大于等于后者
<=	比较前者是否小于等于后者

3、赋值运算符

运算符	描述
=	将运算结果赋值给变量
+=	a+=b 等效于 a=a+b
-=	a-=b 等效于 a=a-b
*=	a*=b 等效于 a=a*b
/=	a/=b 等效于 a=a/b
%=	a%=b 等效于 a=a%b
//=	a//=b 等效于 a=a//b
**=	a**=b 等效于 a=a**b

4、逻辑运算符

运算符	描述
and	“与”运算符，返回布尔类型两个变量“与”运算的结果
or	“或”运算符，返回布尔类型两个变量“或”运算的结果
not	“非”运算符，返回布尔类型对变量“非”运算的结果

5、位运算符

运算符	描述
&	按位“与”运算符：参与运算的两个值换成二进制，如果两个相应位都为 1，则结果为 1，否则为 0
|	按位“或”运算符：参与运算的两个值换成二进制，只要对应的两个二进制位有一个为 1 时，结果就为 1
^	按位“异或”运算符：参与运算的两个值换成二进制，当两对应的二进制位相异时，结果为 1
~	按位“取反”运算符：参与运算的两个值换成二进制，对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1
<<	“左移”运算符：运算数的各二进制位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃， 低位补 0
>>	“右移”运算符：运算数的各二进制位全部右移若干位，由“>>”右边的数指定移动的位数

六、条件语句

if-(elif)-else

if expression:
    statements...
elif expression:
    statements...
     # 可以有1条或多条elif语句
else:
    statement...

注：还有for-else语句，但最好不要用

七、循环语句

1、常见的循环结构

for  in

for 参数 in 循环体：
    执行

while

while 条件:
    执行

range

range()的使用主要是和for循环一起出现的。

range()的形式有三种：

1. range(stop) :默认从0开始，给出结束的int型参数即可，
2. range(start,stop) :
3. range(start,stop,step)

range取左不取右

for i in range(5):
	print(i)


for x in range(1,7):
	print(x)


for y in range(2,19,3):
	print(y)

2、break和continue

break结束当前循环

continue结束当前循环进入下一个循环

i = 0
while i<10:
    i+=1
    if i==5:  #当i=5时，结束整个循环
        break
    print("i=%d"%i)
 
#output
i=1
i=2
i=3
i=4

i = 0
while i<10:
    i+=1
    if i==5:  #当i=5时，结束当前循环进入下一个循环
        continue
    print("i=%d"%i)
 
#output
i=1
i=2
i=3
i=4
i=6
i=7
i=8
i=9
i=10

注意，continue没有输出i=5

八、元组

Python 的元组与列表类似，不同之处在于元组是静态，大小固定，不可以对元素进行增加，修改或删除的操作。

1、元组创建

tup1 = ()
tup2 = ('physics', 'chemistry', 1997, 2000)
tup3 = (1, 2, 3, 4, 5 )
tup4 = "a", "b", "c", "d"
tup5= ((1,2,3),(4,5,6))

#注：元组中只包含一个元素时，需要在元素后面添加逗号
tup6 = (50,)

2、元组访问

元组可以使用下标索引来访问元组中的值

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

#通过下标 
print("tup1[0]: ", tup1[0])
#通过切片a[start : end : step]
print("tup2[1:5]: ", tup2[1:5])

3、元组常用函数

方法	作用
T.index(obj,start,end)	查找某个数据，数据存在返回索引，否则报错
T.count(obj，start，end)	计算指定范围内的某元素出现次数
len(T)	元组长度
sorted(iterable,reverse)	元组排序，默认升序
tuple()	用于将列表、区间（range）等转换为元组

九、字典

字典也被称作关联数组或哈希表。

字典中键不能重复，是唯一的，但是值可以重复

1、字典创建

# 方法1
dic1 = { 'Author' : 'Python' , 'age' : 99 , 'sex' : '男' }

# 方法2
lst = [('Author', 'Python'), ('age', 99), ('sex', '男')]
dic2 = dict(lst)

# 方法3
dic3 = dict( Author = 'Python', age = 99, sex = '男')

# 方法4
list1 = ['Author', 'age', 'sex']
list2 = ['Python', 99, '男']
dic4 = dict(zip(list1, list2))

#注意：访问一个字典里面的某一个值：
dict={"name":"Python","sex":"男"}
print(dict["name"])

2、字典常用函数

dict.clear()

用于清空字典中所有元素（键-值对），对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', 99, '男']
dic1 = dict(zip(list1, list2))
# dic1 = {'Author': 'Python', 'age': 99, 'sex': '男'}

dic1.clear()
# dic1 = {}

 dict.pop()

返回指定键对应的值，并在原字典中删除这个键-值对。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))

sex = dic1.pop('sex')
print('sex = ', sex)
print('dic1 = ',dic1)

# sex = 男
# dic1 = {'Author': 'Python', 'age': [18, 99]}

dict.popitem()

删除字典中的最后一对键和值。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))

dic1.popitem()
print('dic1 = ',dic1)

# dic1 = {'Author': 'Python', 'age': [18, 99]}

 dict.get()

用于返回指定键的值，也就是根据键来获取值，在键不存在的情况下，返回 None，也可以指定返回值。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))

Author = dic1.get('Author')
# Author = Python
phone = dic1.get('phone')
# phone = None
phone = dic1.get('phone','12345678')
# phone = 12345678

 dict.items()

获取字典中的所有键-值对，一般情况下可以将结果转化为列表再进行后续处理。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))

items = dic1.items()
print('items = ', items)
print(type(items))
print('items = ', list(items))

# items = dict_items([('Author', 'Python'), ('age', [18, 99]), ('sex', '男')])
# <class 'dict_items'>
# items = [('Author', 'Python'), ('age', [18, 99]), ('sex', '男')]

 dict.keys()

返回一个字典所有的键。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))

keys = dic1.keys()
print('keys = ', keys)
print(type(keys))
print('keys = ', list(keys))

# keys = dict_keys(['Author', 'age', 'sex'])
# <class 'dict_keys'>
# keys = ['Author', 'age', 'sex']

 dict.values()

返回一个字典所有的值。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))

values = dic1.values()
print('values = ', values)
print(type(values))
print('values = ', list(values))

# values = dict_values(['Python', [18, 99], '男'])
# <class 'dict_values'>
# values = ['Python', [18, 99], '男']

 

dict.update(dict1)

字典更新，将字典dict1的键-值对更新到dict里，如果被更新的字典中己包含对应的键-值对，那么原键-值对会被覆盖，如果被更新的字典中不包含对应的键-值对，则添加该键-值对。

list1 = ['Author', 'age', 'sex']
list2 = ['Python', [18,99], '男']
dic1 = dict(zip(list1, list2))
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python', 'age': [18, 99], 'sex': '男'}

list3 = ['Author', 'phone' ]
list4 = ['1111', 12345678]
dic2 = dict(zip(list3, list4))
print('dic2 = ',dic2)
# dic2 = {'Author': '1111', 'phone': 12345678}

dic1.update(dic2)
print('dic1 = ',dic1)
# dic1 = {'Author': '1111', 'age': [18, 99], 'sex': '男', 'phone': 12345678}

dict.copy()

用于返回一个字典的浅拷贝。

dic1 = { 'Author' : 'Python' , 'age' : 99 , 'sex' : '男' }

dic2 = dic1 # 浅拷贝: 引用对象
dic3 = dic1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic1['age'] = 18

# dic1 = {'Author': 'Python', 'age': 18, 'sex': '男'}
# dic2 = {'Author': 'Python', 'age': 18, 'sex': '男'}
# dic3 = {'Author': 'Python', 'age': 99, 'sex': '男'}

注意：copy.deepcopy()深拷贝

import copy

dic1 = { 'Author' : 'Python' , 'age' :  [18,99] , 'sex' : '男' }

dic2 = dic1
dic3 = dic1.copy()
dic4 = copy.deepcopy(dic1)
dic1['age'].remove(18)
dic1['age'] = 20

# dic1 = {'Author': 'Python', 'age': 20, 'sex': '男'}
# dic2 = {'Author': 'Python', 'age': 20, 'sex': '男'}
# dic3 = {'Author': 'Python', 'age': [99], 'sex': '男'}
# dic4 = {'Author': 'Python', 'age': [18, 99], 'sex': '男'}

dic2 是 dic1 的引用，所以输出结果是一致的；dic3 父对象进行了深拷贝，不会随dic1 修改而修改，子对象是浅拷贝所以数组随 dic1 的修改而修改；dic4 进行了深拷贝，递归拷贝所有数据，相当于完全在另外内存中新建原字典，所以修改dic1不会影响dic4的数据

dict.fromkeys()

使用给定的多个键创建一个新字典，值默认都是 None，也可以传入一个参数作为默认的值。

list1 = ['Author', 'age', 'sex']
dic1 = dict.fromkeys(list1)
dic2 = dict.fromkeys(list1, 'Python')

# dic1 = {'Author': None, 'age': None, 'sex': None}
# dic2 = {'Author': 'Python', 'age': 'Python', 'sex': 'Python'}

十、内置函数

python的内置函数是指不需要导入任何模块就可以直接使用的函数。

目前共有71个内置函数，涉及到输入输出、数据类型、数学运算、进制转换、序列集合操作、文件操作、迭代器相关、作用域相关和其他。

新手必背，Python 全部 71 个内置函数详解🚀 - 知乎 (zhihu.com)

十一、面向对象

Python从设计之初就已经是一门面向对象的语言，在Python中创建一个类和对象是很容易的。

• self 代表类的实例，而非类，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

• __init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

1、创建类：

class Coordinate:
        def __init__(self, x, y):
                self.x = x
                self.y = y
        def __str__(self):
                print(f"({self.x},{self.y})")
        def __add__(self, c1):
                return Coordinate(self.x+c1.x,self.y+c1.y)

x1, y1 = map(int, input().split()) # 1.输入第一行两个数字
x2, y2 = map(int, input().split()) # 1.输入第二行两个数字
c1 = Coordinate(x1, y1) # 2. 调用类
c2 = Coordinate(x2, y2) # 2. 调用类
c3=c1.__add__(c2) # 3. 调用__add__()函数，实现两组数据分别对应相加
c3.__str__() # 4. 调用__str__()函数，打印(相加之后的x, 相加之后的y)

2、类的继承：

        面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

        通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

class 派生类名(基类名)
    ...

class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"
 
   def parentMethod(self):
      print '调用父类方法'
 
   def setAttr(self, attr):
      Parent.parentAttr = attr
 
   def getAttr(self):
      print "父类属性 :", Parent.parentAttr
 
class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"
 
   def childMethod(self):
      print '调用子类方法'
 
c = Child()          #调用子类构造方法
c.childMethod()      # 调用子类方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 
c.getAttr()          # 父类属性 : 200

3、方法重写

class Parent:        # 定义父类
   def myMethod(self):
      print '调用父类方法'
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print '调用子类方法'
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

十二、正则表达式

1、re.match函数

re.match(pattern, string, flags=0)
尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配，(0, 3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配，None

可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式

import re
 
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"



执行结果：
matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter