python基础入门

文章目录

python基础入门

数值类型与基本操作

2**5 # 2的5次方
1.3e5 1.3e-5 # 科学计数法
0xFF # 16进制 0x是16进制前缀
type(a) # 打印数据类型
a = int(input('请输入数据')) # 类型转换
# input()输入数据默认为字符串
# 常见类型 int float str bool list dict-字典 set-集合
abs(5.2) # abs函数——取绝对值
round(5.2) # round函数——四舍五入
min(2,3,4) # min函数——取最小值 可以有若干参数
max(2,3,4) # max函数——取最大值 可以有若干参数

基本数据结构

字符串 str

st = 'jupyter ' + 'python' # 字符串加法 -> 有序拼接 'jupyter python'
st = 'jupyter ' * 3 # 字符串数乘 -> 重复 'jupyter jupyter jupyter'
len(st) # 字符串长度

# 拆分
st = 'Gin Vodka Vermouth Bourbon'
st.split() # 默认按空格拆分字符串 返回列表 ['Gin','Vodka','Vermouth','Bourbon']
st.split('Vodka') # 也可指定拆分间隔 间隔不会计入结果

# 合并
li = ['Gin','Vodka','Vermouth','Bourbon']
st = '\\'
st.join(li) # 以st为衔接合并列表，要求列表中的元素均为字符串类型 
# 'Gin\\Vodka\\Vermouth\\Bourbon'

# 替换
st = 'Gin Vodka Vermouth Bourbon'
st.replace('Bourbon','Zero')

# 大小写
st = 'Vermouth'
st.lower() # vermouth
st.upper() # VERMOUTH

st.strip() # 去除首尾多余空格
st.lstrip() # 去除左边多余空格
st.rstrip() # 去除右边多余空格

# format占位
'{} and {} are black'.format('Gin','Vodka')
# Gin and Vodka are black
'{2} and {1} are black'.format('Gin','Vodka') # 指定索引
# Vodka and Gin are black
'{a} and {b} are black'.format(a='Gin',b='Vodka') # 指定参数
# Gin and Vodka are black

列表 list

有序，可以混合存放任意类型数据，可嵌套，通过索引访问

li = [1,2] + [3,4] # 列表相加 -> 有序拼接 [1,2,3,4]
li = [1,2] * 3 # 列表数乘 -> 重复 [1,2,1,2,1,2]
len(li) # 求列表长度

del li[3:] # 按索引删除某元素
tmp in li # 判断元素tmp是否在列表li中 返回True or False
li.count(tmp) # 计算元素tmp在列表中的个数
li.index(tmp) # 返回元素tmp在列表中首次出现的索引 没找到报错ValueError
li.append(tmp) # 将元素tmp添加进列表最后
li.insert(ind,tmp) # 将元素tmp添加在列表索引ind位置
li.remove(tmp) # 将列表中首个tmp从列表中移除
li.pop() # 将列表尾部的元素弹出 并返回该元素
li.pop(ind) # 将索引ind位置的元素弹出 并返回该元素
li.sort() # 列表升序排序
li.sort(reverse=1) # 列表降序排序
li_sort = sorted(li) # 列表升序排序 将结果储存在新列表中 不改变原列表
li.reverse() # 列表翻转

# 按索引遍历
for i in range(len(li)):
    print(li[i])
# 按元素遍历
for t in li:
    print(t)

索引

用于有序数据结构，如字符串和列表，不用于字典和集合

# 首端正数从0开始，尾端倒数从-1开始
st = '01234567'
st[0] # '0'
st[-1] # '7' 

# 切片
st[0:4] # 左闭右开区间 '0123'
st[4:] # 4到无穷 '4567'
st[:4] # 0到4 '0123'
st[-2:] # 倒数第二到无穷 '67'
st[::3] # 每3个取一个值 '036'

字典 dict

基本结构：key-value 无序，使用key访问value，不可使用索引

di = {'Gin':'black','Bourbon':'red'}
di['Gin'] # 'black'

# 列表转化为字典
di = dict([('amy',89), ('tom',90)])
# {'amy': 89, 'tom': 90}
di.get('amy') # 89 
di.get('sam') # 没找到 但不会报错
di.get('sam','none') # 返回none
di.pop('amy') # 弹出指定key-value 并返回value
di['tom'] +=10 # {'tom',100} value可以被运算
del di['tom'] # 删除指定key-value


di = {'Gin':'black','Bourbon':'red'}
di.update({'Gin':'black','Vodka':'black'}) # 更新

'Gin' in di # True
di.keys() # 返回字典di的所有key 类型为dict_keys 可用于遍历
di.values() # 返回字典di的所有value 类型为dict_values 可用于遍历
tang.items() # 返回字典di的所有key-value对

# 遍历
for key in di.keys():
    print(di[key])

集合 set

集合内元素不重复，无序，可以进行一些集合间的数学运算/判断

li = [1,1,2,3,5,8]
se = set(li) # {1,2,3,5,8}
li = list(se) # 与list可以互相转化

a = {1,2,3,4}
b = {2,3,4}
a | b # 并集 {1,2,3,4}
a & b # 交集 {2,3,4}
a - b # 在a里面 不在b里面的元素 {1}
b <= a # True 判断子集
a <= a # True
a.update([4,5,6]) # 更新 {1,2,3,4,5,6}
a.remove(1) # 移除指定元素
a.pop() # 弹出并返回首部元素

逻辑结构

判断结构

通过and/or连接多个判断条件

三个及以上判断结果用elif表示

使用: 和缩进表示逻辑从属

a = 90
if a > 100 and a <= 200: 
    print('if')
elif a == 50 or a == 90:
    print('elif1')
elif (a <10 and a > 0) or a > 200:
    print('elif2')
else:
    print('else')

循环结构

while 循环

a = 0
while a < 5:
    print(a)
    a += 1

se = {'Gin','Vodka','Bourbon'}
while se:
    print(se.pop())

for循环

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

di = {'Gin':'black','Vodka':'black','Bourbon':'red'}
for key in di.keys():
    print(di[key])

函数

参数和返回值根据需要设定，通过def关键字、:和缩进表示逻辑从属

def print_value(a):
    print('The value of a is ',a)
    
def add_value(a=1,b=2): # 为参数设置默认值
    print('a+b is ',a+b)
    
def add_number(a,*args): # 接受不定个数的参数
    b = 0
    for i in args:
        a += i
        b += a
    return a,b # 返回值可以有多个
a,b = add_number(1,2,3)
print (a,b) # 6 9
        
def add_2(a,**kwargs): # **kwargs可传入不定个数的key-value对
    for arg,value in kwargs.items():
        print(arg,value)
add_2(1,x=2,y=3)
# x 2
# y 3

包

%%writefile test.py 
# writefile用于在jupyter中新建文件

value = 10010

def test_function():
    print('success')

# 导入包
import test as te # 整个导入包 调用时需用te.
print(te.value) # 10010
te.test_function() # success

from test import value,test_function # 导入包中的部分变量和函数 直接使用无需.
print(value) # 10010
te.test_function() # success

from test import * # 导入包中的部分变量和函数 直接使用无需.
print(te.value) # 10010
te.test_function() # success

类

class people:
    '帮助信息：这是一个帮助信息' # 类的自带属性
    location = 'earth' # 所有实例都会共享number
    def __init__(self,name,age): # 构造函数
        self.name = name
        self.age = age
    def show_name(self):
        print(self.name)

per1 = people('Vodka',40) # 实例化
per1.name = 'Gin' # 访问per1的name变量
per2.show_name() # 访问per2的show_name函数
del per1.name # 删除实例per1的name属性
hasattr(per1,'age') # True 查看实例是否具有某一属性
hasattr(per1,'name') # False 被删除的属性和不存在的属性返回False
getattr(per1,'age') # 获取实例per1的属性age
setattr(per1,'name','Gin') # 为实例per1设置name属性
setattr(per1,'sex','male') # 可以设置类中没有的属性
delattr(per1,'sex') # 删除per1的sex属性

print(peolpe.__doc__) # 帮助信息
print (people.__name__) # 类的名字
print (people.__module__) # 类的定义所在的模块
print (people.__bases__) # 父类的构成
print (people.__dict__) # 类的组成


# 继承
class Dad: # 父类
    def __init__(self):
        print ('父类构造函数')
    def dadFunction(self):
        print ('父类方法')
    def sameName(self):
        print ('来自dad')
        
class son(Dad): # Dad的子类
    def __init__(self):
        print ('子类构造函数')
    def sonFunction(self):
        print ('子类方法')
    def sameName(self):
        print ('来自子类')

child = son() # 子类构造函数
child.dadFunction() # 父类方法
child.sonFunction() # 子类方法
child.sameName() # 来自子类

基础操作

异常处理

用以防止报错导致的程序中断

li = [1,0]
for tmp in li:
    try:
        print('front') # 报错语句前的语句可以被执行
        print(1/tmp) # 报错 跳转至except 该语句不会被执行
        print('last') # 报错语句后的语句不可以被执行
    except ZeroDivisionError:
        print('不可以除0')

        
# 涵盖所有报错类型
import math
for i in range(10):
    try:
        input_number = input('write a number')
        if input_number == 'q':
            break
        result = 1/math.log(float(input_number))
        print (result)
    except ValueError:
        print ('ValueError: input must > 0')
    except ZeroDivisionError:
        print ('log(value) must != 0')
    except Exception: # 其他的可能性
        print ('unknow error')
        
# finally
try:
    1 / 0
except:
    print('不可以除0')
finally:
    print('finally') # 无论try中是否有异常，finally都会被执行

    
    
# 自定义错误类型
class NumNotInList(ValueError): # 自定义的一种异常
    pass
li = [1,2,3]
while True:
    num = int(input('input a number: '))
    if num not in li:
        raise NumNotInList('数字{}不在列表中'.format(num))
        # 抛出一个错误 输入不在列表中的数字时报错终止 并显示错误类型为NumNotInList

文件处理

txt = open('./test.txt') # ./ 即本代码所在的路径
txt_str = txt.read() # read函数返回文本内容
txt_lines = txt.readlines() # readlines返回列表 文本每一行组成一个元素 包括换行符
txt.close() # 文件打开后要记得关闭

txt = open('test.txt','w') # 以覆盖写入模式打开文件 一旦写入丢失原有数据
txt.write('123')
txt.close()

txt = open('test.txt','a') # 以追加写入模式打开文件 在原有数据后面写入新的数据
txt.write('\n321')
txt.close()

txt = open('test.txt','r') # 以只读模式打开文件 可以读取文件内容
print (txt.read())
txt.close()

with open('test.txt','w') as f:
    f.write('123\n321') 
    # with方法会自动close 且自带类似try-except的防止报错功能 较为常用

系统时间

所在包：time.py

import time
print(time.time()) # 从1970年1月1日到现在经过了多长时间
print (time.localtime(time.time()))
# time.struct_time(tm_year=2022, tm_mon=2, tm_mday=4, tm_hour=23, tm_min=18, tm_sec=46, tm_wday=4, tm_yday=35, tm_isdst=0)
print (time.asctime(time.localtime(time.time())))
# Fri Feb  4 23:18:38 2022
print (time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
# 2022-02-04 23:19:17
time.sleep(10) # 程序停止十秒