python基础回顾

chr(x) 将Unicode代码转成字符
ord(x) 将字符转成Unicode代码 小写字母的编码大于大写字母
str
s.find('x') 返回索引号第一次出现的位置无则返回-1
s.rfind('x') 最后一次出现的位置，没有返回-1
s.index('x') 第一次出现的位置，没有报错
s.rindex('x') 最后一次出现的位置，没有报错
s.count('x') x在s中出现的次数没有返回0
s.split(',') 按,分割字符串默认按空格 换行符 制表符，返回值列表
s.split(maxsplit=2)从左开始最大分隔次数为2
s.rsplit(maxsplit=2)从右开始最大分隔次数为2
s.partition('fish') 分隔成fish前，fish，fish后；从左遇到的第一个fish；无返回fish和两个空字符串
s.rpartition('fish') 从右边开始
':'.join(lst) 列表中用 指定符号连接字符串
s.lower() 返回小写字符串
s.upper() 返回大写字符串
s.captilize() 首字母大写
s.title 每个单词首字母大写
s.swapcase() 大小写互换
s.replace('a', 'b') a替换成b 返回新的字符串
s.strip() 删除两端空格
s.rstrip() 删除右端空格
s.lstrip() 删除左端空格
s.strip('=') 删除两端=
s.rstrip('=') 删除右端=
s.lstrip('=') 删除左端=
s.stratwith('x') 是否以x开始
s.endwith('x') 是否以x结束
s.islower() 是否全部小写
s.isupper() 是否全部大写
s.isdigit() 是否全数字
s.isalnum() 是否数字字母汉字
s.isalpha() 是否字母汉字
s.center(30, '=') 居中对齐，输出宽度为30，不足用=填充
s.ljust(20,'=') 靠左对齐
s.rjust(20,'=') 靠右对齐
s.zfill(20) 输出宽度为20，左侧以0填充

格式化format()
指定顺序填充 'xx{1}xx'{0}'xx{2}'.form('x','y','z') x 0 y 1 z 2
默认顺序填充从左往右 'xx{}xx'{}'xx{}'.form('x','y','z')
格式设置 {:填充字符 对齐方式 宽度}
'{:*^20}'.format('mike')宽度20居中*填充 对齐方式^居中 <左对齐 >右对齐
实数和整数设置
'{:.2f}'.format(3.1415926) 保留两位小数
'{:=^30.4f}'.format(3.1415087) 保留四位小数,长度30，=号填充
'{:5d}'.format(2323) 整数输出，宽度为5 默认填充空格

random from random import *
random() 返回0-1之间随机浮点数
randrange(n);randrange(m,n) 给定区间返回区间内随机数 ()中只能给整数，小数会报错
randint(m,n) 从m到n的整数，两边都能取到
choice(s) 序列s中随机选择一个元素
uniform(m,n) m,n内随机小数
sample(pop,k) 从pop类型随机选取k函数 返回列表
>>> sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
['blue', 'red', 'red', 'blue', 'red']
>>> sample(range(20),k=5)
[4, 19, 2, 16, 0]
>>> sample(range(20),k=5)
[0, 5, 1, 14, 13]
shuffle(s) 序列类型中元素随机排列，返回打乱后序列s
>>> s=[0, 5, 1, 14, 13]
>>> shuffle(s)
>>> s
[13, 14, 0, 5, 1]
seed(n) 重置随机数生成器

列表 list
list.append() 指定列表尾部追加新元素
list.insert(索引, 元素) 新增元素插入指定索引位置
del list 删除整个列表 del list[0] 删除指定索引位置元素
list.pop(索引) 删除指定元素同时返回被删值 pop()默认删除最后一个元素并返回被删值
list.remove(元素) 删除指定元素值从左到右第一个
list.extend(list2) 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） 参数为可迭代序列 如果是字符串会拆开字符串
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> id(a)
2457208926912
>>> id(b)
2457205785920
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
>>> id(a)
2457208926912
>>> a.extend('abc')
>>> a
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c']
list.index(元素) 返回元素索引无则报错
list.count(元素) 返回元素个数无则返回0
list.sort() 列表升序排序不改变原数据；reverse=True 降序
sorted(list) 升序返回新列表，改变元数据 reverse=True 降序
>>> a=[3,5,6,2,8,1,0]
>>> id(a)
2457208891968
>>> a.sort()
>>> a
[0, 1, 2, 3, 5, 6, 8]
>>> id(a)
2457208891968
>>> b=sorted(a,reverse=True)
>>> b
[8, 6, 5, 3, 2, 1, 0]
>>> id(b)
2457208926912
====
eval(input('please a num')) 自动识别输入元素数据类型
可变数据类型 list set dict
不可变数据类型 tuple int str
====
元组 tuple
zip(lst1,lst2)
>>> a
[3, 5, 6, 8]
>>> b
[0, 1, 2]
>>> for i in zip(a,b):
... print(i)
...
(3, 0)
(5, 1)
(6, 2)
元组和列表之间的转换
tuple(list) 列表转换成元组
list(tuple) 元组转换成列表

字典 dict 键值对
键不可变，唯一性，可用于去重 求字符串字符个数
del dict[key] / del dictnae
dict.pop(key) 返回被删的value
dict.popitem) 随机删除字典条目，返回被删键值对以元组的形式
dict.clear() 清空字典条目
key in dict 返回ture/false
dict.get(key) key不存在时不报错
字典的遍历
for i in dict.keys(): #遍历字典所有的key for i in dict: 返回字典所有的key
print(i)
for i in dict.values(): #遍历字典所有的值
print(i)
for i in dict.items(): #遍历字典所有的键值对 返回元组
print(i)
sorted(dict) 将字典的键排序返回列表
>>> a
{4: 3, 3: 3, 2: 2, 1: 0}
>>> sorted(a)
[1, 2, 3, 4]
>>> for i in sorted(a):
... print(i,'--',a[i])
...
1 -- 0
2 -- 2
3 -- 3
4 -- 3
items() 返回元组键值对所有的
>>> t=[(v,k) for v,k in a.items()]
>>> t
[(4, 3), (3, 3), (2, 2), (1, 0)]
>>>
update()
dict1.update(dict2)
>>> a
{4: 3, 3: 3, 2: 2, 1: 0}
>>> b={'a':'a','b':'b'}
>>> b
{'a': 'a', 'b': 'b'}
>>> a.update(b)
>>> a
{4: 3, 3: 3, 2: 2, 1: 0, 'a': 'a', 'b': 'b'}

集合 set 自动去重 元素不可重复 唯一性
set.add(x) 添加新元素x 添加列表会报错
set.update('abc') 拆分后按单个元素添加 可添加列表
set.remove(x) 删除指定元素 无该元素则报错
set.discard(x) 删除指定元素，无该元素不报错
set.pop() 随机删除一个元素并返回被删值
set.clear() 清空所有元素
x in set 返回true / false

>>> b
{0, 1, 2, 3}
>>> a
{1, 2, 3, 4, 5}
set1 | set2 并集
>>> a | b
{0, 1, 2, 3, 4, 5}
set1 & set2 交集
>>> a & b
{1, 2, 3}
set1 - set2 差集
>>> a-b
{4, 5}
>>> b-a
{0}
set1 ^ set2 对称差集
>>> a^b
{0, 4, 5}

函数
lambda匿名函数 参数1，参数2:<函数语句 >
c=lambda x: x**2

中文文本分析相关库 jieba import jieba

画图库 matplotlib

pandas库
两种数据结构 Series对象 DataFrame对象
Series对象
>>> import pandas as pd
>>> s1 = pd.Series([2,3,4,5])
>>> s1
0 2
1 3
2 4
3 5
dtype: int64
前面是索引后边是值
values 和 index 属性获取数据和索引
>>> s1.values
array([2, 3, 4, 5], dtype=int64)
>>> s1.index
RangeIndex(start=0, stop=4, step=1)
指定索引 index 默认索引也是存在的
>>> s2=['a','b','c','d']
>>> pd.Series([1,2,3,4],index=s2)
a 1
b 2
c 3
d 4
dtype: int64
标量乘法
s1**2
>>> s1
0 2
1 3
2 4
3 5
dtype: int64
>>> s1**2
0 4
1 9
2 16
3 25
dtype: int64
数据过滤
s1[()&()] 并且 小括号不能省略
s1[()|()]或者 小括号不能省略
>>> s1[(s1>2)&(s1<4)]
1 3
dtype: int64

s1[s1>4]
>>> s1[s1>4]
3 5
应用于数学函数
numpy.sqrt(s1)
>>> import numpy
>>> numpy.sqrt(s1)
0 1.414214
1 1.732051
2 2.000000
3 2.236068
dtype: float64
访问 s1[索引]
修改 s1[索引]=3 有则返回无则创建
相加 s1+s2 相同索引数据求和 ，没有返回NaN
>>> s1+s2
0 2.414214
1 4.732051
2 6.000000
3 7.236068
4 NaN
dtype: float64
判断 pd.isnull(s1+s2) pd.notnull(s1+s2)
判断是否有匹配的索引
>>> pd.notnull(s1+s2)
0 True
1 True
2 True
3 True
4 False
dtype: bool

DataFrame对象
创建 通过字典直接转换 每个键对于的数据是等长的列表或者numpy组合
>>> colu=[f'col_{i}' for i in range(3)]
>>> inde=[f'row_{i}' for i in range(10)]
>>> nums
[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
>>> pd.DataFrame(data=nums, index=inde, columns=colu)
col_0 col_1 col_2
row_0 0 1 2
row_1 0 1 2
row_2 0 1 2
row_3 0 1 2
row_4 0 1 2
row_5 0 1 2
row_6 0 1 2
row_7 0 1 2
row_8 0 1 2
row_9 0 1 2
通过属性查看基本信息
df.shape 形状
df.index 行索引
df.columns 列索引
df.values 返回所有数据
df.info() 摘要信息
>>> df.shape
(10, 3)
>>> df.index
Index(['row_0', 'row_1', 'row_2', 'row_3', 'row_4', 'row_5', 'row_6', 'row_7',
'row_8', 'row_9'],
dtype='object')
>>> df.columns
Index(['col_0', 'col_1', 'col_2'], dtype='object')
>>> df.values
array([[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2],
[0, 1, 2]], dtype=int64)
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
Index: 10 entries, row_0 to row_9
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 col_0 10 non-null int64
1 col_1 10 non-null int64
2 col_2 10 non-null int64
dtypes: int64(3)
memory usage: 320.0+ bytes

df1=df.set_index['colum_name'] 将某列设置为新索引 原索引还在
按照索引读取 df[0:2]
>>> df
城市 人口 GDP
2 1 2 3
1 2 3 4
4 3 4 5
3 4 5 6
>>> df[0:2]
城市 人口 GDP
2 1 2 3
1 2 3 4
df.head(2) 取前两行
df.tail(1) 取最后一行
df['GDP'] 选择列

读取文件
df = pd.read_csv('file.csv')
导出文件
df.to_csv('newfile.csv')

loc方法
筛选数据 排序 数据分组 求和

jekins /restart 重启jekins
admin 默认密码 I:\ProgramData\Jenkins\.jenkins\secrets>type initialAdminPassword
939fafe9d4ca467ab0baa154ac9a7bfd
Manage Jekins->Manage Plugin Available 插件
汉化插件
用户权限插件 Role-based Authorization Strategy
凭证管理插件 Credentials Binding
git插件
jekins 调用python 不是内部命令 需要在jekins中设置环境变量 manage jenkins

 

装饰器
不改变原本函数的基础上新加功能函数
装饰器函数的参数是一个函数，内嵌一个函数，返回值为内嵌函数 return 内嵌函数

import time


def ptime(func):
    def f(maxnum):
        s1 = time.time()
        res = func(maxnum)
        s2 = time.time()
        print('耗时总计：{:.4f}'.format(s2 - s1))
        return res

    return f


def is_prime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True


@ptime
def prime(maxnum):
    pcount = 0
    for i1 in range(2, maxnum):
        if is_prime(i1):
            pcount += 1
    return pcount


c = prime(10000)
print(c)

递归
函数的返回值调用函数本身 return 函数自己

递归阶乘
2！= 1 * 2   n * (n - 1)
def factor(n):
    if n < 2:
        return 1
    return n * factor(n - 1)

闭包
内部函数调用外部函数变量 保证数据安全
外部函数返回值为内部函数 return 内部函数

def sun():
    li = []

    def inn(val):
        li.append(val)
        return sum(li) / len(li)

    return inn


ab = sun()
print(ab(2000))
print(ab(3000))
print(ab(4000))

#冒泡

ar = [10, 20, 5, 6, 8, 25, 58, 30]
for i in range(0, len(ar) - 1):
    for j in range(0, len(ar) - 1 - i):
        if ar[j] > ar[j + 1]:
            ar[j], ar[j + 1] = ar[j + 1], ar[j]
print(ar)