python7

Posted 林木森3

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python7相关的知识,希望对你有一定的参考价值。

# 代码12-1 评论去重的代码

import pandas as pd
import re
import jieba.posseg as psg
import numpy as np


# 去重,去除完全重复的数据
reviews = pd.read_csv("D:/JupyterLab-Portable-3.1.0-3.9/新建文件夹/第十二章/reviews.csv")
reviews = reviews[[\'content\', \'content_type\']].drop_duplicates()
content = reviews[\'content\']

2

# 代码12-2 数据清洗

# 去除去除英文、数字等
# 由于评论主要为京东美的电热水器的评论,因此去除这些词语
strinfo = re.compile(\'[0-9a-zA-Z]|京东|美的|电热水器|热水器|\')
content = content.apply(lambda x: strinfo.sub(\'\', x))

3

# 代码12-3 分词、词性标注、去除停用词代码

# 分词
worker = lambda s: [(x.word, x.flag) for x in psg.cut(s)] # 自定义简单分词函数
seg_word = content.apply(worker)

# 将词语转为数据框形式,一列是词,一列是词语所在的句子ID,最后一列是词语在该句子的位置
n_word = seg_word.apply(lambda x: len(x))  # 每一评论中词的个数

n_content = [[x+1]*y for x,y in zip(list(seg_word.index), list(n_word))]
index_content = sum(n_content, [])  # 将嵌套的列表展开,作为词所在评论的id

seg_word = sum(seg_word, [])
word = [x[0] for x in seg_word]  #

nature = [x[1] for x in seg_word]  # 词性

content_type = [[x]*y for x,y in zip(list(reviews[\'content_type\']), list(n_word))]
content_type = sum(content_type, [])  # 评论类型

result = pd.DataFrame("index_content":index_content,
                       "word":word,
                       "nature":nature,
                       "content_type":content_type)

# 删除标点符号
result = result[result[\'nature\'] != \'x\']  # x表示标点符号

# 删除停用词
stop_path = open("D:/JupyterLab-Portable-3.1.0-3.9/新建文件夹/第十二章/stoplist.txt", \'r\',encoding=\'UTF-8\')
stop = stop_path.readlines()
stop = [x.replace(\'\\n\', \'\') for x in stop]
word = list(set(word) - set(stop))
result = result[result[\'word\'].isin(word)]

# 构造各词在对应评论的位置列
n_word = list(result.groupby(by = [\'index_content\'])[\'index_content\'].count())
index_word = [list(np.arange(0, y)) for y in n_word]
index_word = sum(index_word, [])  # 表示词语在改评论的位置

# 合并评论id,评论中词的id,词,词性,评论类型
result[\'index_word\'] = index_word

4

# 代码12-4 提取含有名词的评论

# 提取含有名词类的评论
ind = result[[\'n\' in x for x in result[\'nature\']]][\'index_content\'].unique()
result = result[[x in ind for x in result[\'index_content\']]]

5# 代码12-5 绘制词云

import matplotlib.pyplot as plt
from wordcloud import WordCloud

frequencies = result.groupby(by = [\'word\'])[\'word\'].count()
frequencies = frequencies.sort_values(ascending = False)
backgroud_Image=plt.imread(\'D:\\JupyterLab-Portable-3.1.0-3.9\\新建文件夹\\第十二章\\pl.jpg\')
wordcloud = WordCloud(font_path="C:\\Windows\\Fonts\\STZHONGS.ttf",
                      max_words=100,
                      background_color=\'white\',
                      mask=backgroud_Image)
my_wordcloud = wordcloud.fit_words(frequencies)
plt.imshow(my_wordcloud)
plt.axis(\'off\')
plt.show()
# 将结果写出
result.to_csv("D:/python123/word.csv", index = False, encoding = \'utf-8\')

 

 

#匹配情感词
word = pd.read_csv("./tmp/word.csv")
# 读入正面、负面情感评价词
pos_comment = pd.read_csv("./data/正面评价词语(中文).txt", header=None,sep="\\n", 
                          encoding = \'utf-8\', engine=\'python\')
neg_comment = pd.read_csv("./data/负面评价词语(中文).txt", header=None,sep="\\n", 
                          encoding = \'utf-8\', engine=\'python\')
pos_emotion = pd.read_csv("./data/正面情感词语(中文).txt", header=None,sep="\\n", 
                          encoding = \'utf-8\', engine=\'python\')
neg_emotion = pd.read_csv("./data/负面情感词语(中文).txt", header=None,sep="\\n", 
                          encoding = \'utf-8\', engine=\'python\') 

# 合并情感词与评价词
positive = set(pos_comment.iloc[:,0])|set(pos_emotion.iloc[:,0])
negative = set(neg_comment.iloc[:,0])|set(neg_emotion.iloc[:,0])

# 正负面情感词表中相同的词语
intersection = positive&negative
positive = list(positive - intersection)
negative = list(negative - intersection)
positive = pd.DataFrame("word":positive,"weight":[1]*len(positive))
negative = pd.DataFrame("word":negative,"weight":[-1]*len(negative)) 
posneg = positive.append(negative)


# 将分词结果与正负面情感词表合并,定位情感词
data_posneg = posneg.merge(word, left_on = \'word\', right_on = \'word\', how = \'right\')
data_posneg = data_posneg.sort_values(by = [\'index_content\',\'index_word\'])

data_posneg.head()

 

 

# 修正情感倾向

# 根据情感词前时候有否定词或双层否定词对情感值进行修正
# 载入否定词表
notdict = pd.read_csv("./data/not.csv")

# 构造新列,作为经过否定词修正后的情感值
data_posneg[\'amend_weight\'] = data_posneg[\'weight\']
data_posneg[\'id\'] = np.arange(0, len(data_posneg))

# 只保留有情感值的词语
only_inclination = data_posneg.dropna().reset_index(drop=True)
index = only_inclination[\'id\']

for i in np.arange(0, len(only_inclination)):
    # 提取第i个情感词所在的评论
    review = data_posneg[data_posneg[\'index_content\'] == only_inclination[\'index_content\'][i]]
    review.index = np.arange(0, len(review))
    # 第i个情感值在该文档的位置
    affective = only_inclination[\'index_word\'][i]
    if affective == 1:
        ne = sum([i in notdict[\'term\'] for i in review[\'word\'][affective - 1]])%2
        if ne == 1:
            data_posneg[\'amend_weight\'][index[i]] = -data_posneg[\'weight\'][index[i]]          
    elif affective > 1:
        ne = sum([i in notdict[\'term\'] for i in review[\'word\'][[affective - 1, 
                  affective - 2]]])%2
        if ne == 1:
            data_posneg[\'amend_weight\'][index[i]] = -data_posneg[\'weight\'][index[i]]
            
            
# 更新只保留情感值的数据
only_inclination = only_inclination.dropna()

# 计算每条评论的情感值
emotional_value = only_inclination.groupby([\'index_content\'],as_index=False)[\'amend_weight\'].sum()

# 去除情感值为0的评论
emotional_value = emotional_value[emotional_value[\'amend_weight\'] != 0]
# 给情感值大于0的赋予评论类型(content_type)为pos,小于0的为neg
emotional_value[\'a_type\'] = \'\'
emotional_value[\'a_type\'][emotional_value[\'amend_weight\'] > 0] = \'pos\'
emotional_value[\'a_type\'][emotional_value[\'amend_weight\'] < 0] = \'neg\'

emotional_value.head()

 

 

 
# 查看情感分析结果
result = emotional_value.merge(word, 
                               left_on = \'index_content\', 
                               right_on = \'index_content\',
                               how = \'left\')
result.head()

 

 

 
result = result[[\'index_content\',\'content_type\', \'a_type\']].drop_duplicates()
result.head()

 

 

 
# 交叉表:统计分组频率的特殊透视表
confusion_matrix = pd.crosstab(result[\'content_type\'], result[\'a_type\'], 
                               margins=True)
confusion_matrix.head()

 

 

 
(confusion_matrix.iat[0,0]+confusion_matrix.iat[1,1])/confusion_matrix.iat[2,2]
# 提取正负面评论信息
ind_pos = list(emotional_value[emotional_value[\'a_type\'] == \'pos\'][\'index_content\'])
ind_neg = list(emotional_value[emotional_value[\'a_type\'] == \'neg\'][\'index_content\'])
posdata = word[[i in ind_pos for i in word[\'index_content\']]]
negdata = word[[i in ind_neg for i in word[\'index_content\']]]

# 绘制词云
import matplotlib.pyplot as plt
from wordcloud import WordCloud

# 正面情感词词云
freq_pos = posdata.groupby(\'word\')[\'word\'].count()
freq_pos = freq_pos.sort_values(ascending = False)
backgroud_Image=plt.imread("./data/pl.jpg")
wordcloud = WordCloud(font_path="simsun.ttc",
                      max_words=100,
                      background_color=\'white\',
                      mask=backgroud_Image)
pos_wordcloud = wordcloud.fit_words(freq_pos)
plt.imshow(pos_wordcloud)
plt.axis(\'off\') 
plt.show()

# 负面情感词词云
freq_neg = negdata.groupby(by = [\'word\'])[\'word\'].count()
freq_neg = freq_neg.sort_values(ascending = False)
neg_wordcloud = wordcloud.fit_words(freq_neg)
plt.imshow(neg_wordcloud)
plt.axis(\'off\') 
plt.show()
# 将结果写出,每条评论作为一行
posdata.to_csv("./tmp/posdata.csv", index = False, encoding = \'utf-8\')
negdata.to_csv("./tmp/negdata.csv", index = False, encoding = \'utf-8\')

 

 

 

 

#建立词典及语料库
import pandas as pd
import numpy as np
import re
import itertools
import matplotlib.pyplot as plt
# 载入情感分析后的数据
posdata = pd.read_csv("./data/posdata.csv", encoding = \'utf-8\')
negdata = pd.read_csv("./data/negdata.csv", encoding = \'utf-8\')

from gensim import corpora, models
# 建立词典
pos_dict = corpora.Dictionary([[i] for i in posdata[\'word\']])  # 正面
neg_dict = corpora.Dictionary([[i] for i in negdata[\'word\']])  # 负面

# 建立语料库
pos_corpus = [pos_dict.doc2bow(j) for j in [[i] for i in posdata[\'word\']]]  # 正面
neg_corpus = [neg_dict.doc2bow(j) for j in [[i] for i in negdata[\'word\']]]   # 负面
# 余弦相似度函数
def cos(vector1, vector2):
    dot_product = 0.0;  
    normA = 0.0;  
    normB = 0.0;  
    for a,b in zip(vector1, vector2): 
        dot_product += a*b  
        normA += a**2  
        normB += b**2  
    if normA == 0.0 or normB==0.0:  
        return(None)  
    else:  
        return(dot_product / ((normA*normB)**0.5))   

# 主题数寻优
def lda_k(x_corpus, x_dict):  
    
    # 初始化平均余弦相似度
    mean_similarity = []
    mean_similarity.append(1)
    
    # 循环生成主题并计算主题间相似度
    for i in np.arange(2,11):
        # LDA模型训练
        lda = models.LdaModel(x_corpus, num_topics = i, id2word = x_dict)
        for j in np.arange(i):
            term = lda.show_topics(num_words = 50)
            
        # 提取各主题词
        top_word = []
        for k in np.arange(i):
            top_word.append([\'\'.join(re.findall(\'"(.*)"\',i)) \\
                             for i in term[k][1].split(\'+\')])  # 列出所有词
           
        # 构造词频向量
        word = sum(top_word,[])  # 列出所有的词   
        unique_word = set(word)  # 去除重复的词
        
        # 构造主题词列表,行表示主题号,列表示各主题词
        mat = []
        for j in np.arange(i):
            top_w = top_word[j]
            mat.append(tuple([top_w.count(k) for k in unique_word]))  
            
        p = list(itertools.permutations(list(np.arange(i)),2))
        l = len(p)
        top_similarity = [0]
        for w in np.arange(l):
            vector1 = mat[p[w][0]]
            vector2 = mat[p[w][1]]
            top_similarity.append(cos(vector1, vector2))
            
        # 计算平均余弦相似度
        mean_similarity.append(sum(top_similarity)/l)
    return(mean_similarity)

# 计算主题平均余弦相似度
pos_k = lda_k(pos_corpus, pos_dict)
neg_k = lda_k(neg_corpus, neg_dict)

# 绘制主题平均余弦相似度图形
from matplotlib.font_manager import FontProperties  
font = FontProperties(size=14)
#解决中文显示问题
plt.rcParams[\'font.sans-serif\']=[\'SimHei\']
plt.rcParams[\'axes.unicode_minus\'] = False  
fig = plt.figure(figsize=(10,8))
ax1 = fig.add_subplot(211)
ax1.plot(pos_k)
ax1.set_xlabel(\'正面评论LDA主题数寻优(3127)\', fontproperties=font)

ax2 = fig.add_subplot(212)
ax2.plot(neg_k)
ax2.set_xlabel(\'负面评论LDA主题数寻优(3127)\', fontproperties=font)

# 代码12-11 LDA主题分析

# LDA主题分析
pos_lda = models.LdaModel(pos_corpus, num_topics = 3, id2word = pos_dict)
neg_lda = models.LdaModel(neg_corpus, num_topics = 3, id2word = neg_dict)
pos_lda.print_topics(num_words = 10)
[(0,
\'0.028*"满意" + 0.027*"服务" + 0.024*"送货" + 0.019*"东西" + 0.015*"太" + 0.015*"装" + 0.012*"物流" + 0.010*"第二天" + 0.010*"服务态度" + 0.009*"打电话"\'),
(1,
\'0.162*"安装" + 0.038*"师傅" + 0.031*"不错" + 0.019*"客服" + 0.017*"人员" + 0.014*"安装费" + 0.012*"产品" + 0.011*"品牌" + 0.011*"质量" + 0.011*"好评"\'),
(2,
\'0.047*"差" + 0.044*"售后服务" + 0.043*"超级" + 0.027*"售后" + 0.022*"免费" + 0.014*"收费" + 0.014*"电话" + 0.014*"很快" + 0.011*"值得" + 0.010*"花"\')]

neg_lda.print_topics(num_words = 10)
[(0,
\'0.122*"安装" + 0.050*"太" + 0.038*"评" + 0.031*"师傅" + 0.026*"客服" + 0.023*"售后" + 0.018*"不好" + 0.015*"坏" + 0.013*"产品" + 0.013*"材料费"\'),
(1,
\'0.078*"差" + 0.035*"垃圾" + 0.023*"东西" + 0.018*"打电话" + 0.016*"质量" + 0.015*"换" + 0.014*"慢" + 0.013*"货" + 0.013*"遥控器" + 0.012*"贵"\'),
(2,
\'0.025*"安装费" + 0.025*"装" + 0.019*"收" + 0.019*"加热" + 0.018*"服务" + 0.015*"太慢" + 0.013*"上门" + 0.013*"小时" + 0.012*"遥控" + 0.010*"失望"\')]

# LDA主题分析
pos_lda = models.LdaModel(pos_corpus, num_topics=3, id2word=pos_dict)
neg_lda = models.LdaModel(neg_corpus, num_topics=3, id2word=neg_dict)
pos_lda.print_topics(num_words=10)
neg_lda.print_topics(num_words = 10)
[(0,
\'0.117*"安装" + 0.036*"评" + 0.035*"垃圾" + 0.025*"安装费" + 0.017*"不好" + 0.015*"换" + 0.014*"太慢" + 0.014*"慢" + 0.013*"货" + 0.013*"上门"\'),
(1,
\'0.075*"差" + 0.029*"师傅" + 0.024*"客服" + 0.024*"装" + 0.018*"加热" + 0.017*"打电话" + 0.015*"质量" + 0.012*"遥控" + 0.011*"坑人" + 0.008*"问"\'),
(2,
\'0.052*"太" + 0.025*"东西" + 0.024*"售后" + 0.021*"收" + 0.019*"服务" + 0.016*"坏" + 0.014*"遥控器" + 0.014*"产品" + 0.013*"材料费" + 0.013*"贵"\')]

 

python初识

变量

一、定义方式

  • 下划线(推荐使用) age_of_oldboy = 56
  • 变量名只能是 字母、数字或下划线的任意组合
  • 变量名的第一个字符不能是数字
  • 关键字不能声明为变量名[\'and\', \'as\', \'assert\', \'break\', \'class\', \'continue\', \'def\', \'del\', \'elif\', \'else\', \'except\', \'exec\', \'finally\', \'for\', \'from\', \'global\', \'if\', \'import\', \'in\', \'is\', \'lambda\', \'not\', \'or\', \'pass\', \'print\', \'raise\', \'return\', \'try\', \'while\', \'with\', \'yield\']

二、id、type、value、is、in、hash

  • 身份:即内存地址,可以用id()来获取
  • 类型:决定了该对象保存的类型,需要遵循什么规则,可用type()来获取该数据类型
  • 值:对象的保存的的真实数据
  • 等号比较的是value
  • is比较的是id
  • id相同,意味着type和value必定相同
  • value相同type肯定相同,但id可能不同
  • 可变:值变,id不变。可变==不可hash
  • 不可变:值变,id就变。不可变==可hash
  • is运算符用于比较两个对象的身份
  • in主要用来判断某一元素是否在某种元素集合中
  • 可hash的就是不可变数据类型,不可hash的就是可变数据类型

三、类型分类

  • 可变类型:在id不变的情况下,value可以变,则称为可变类型,如列表,字典
  • 不可变类型:value一旦改变,id也改变,则称为不可变类型(id变,意味着创建了新的内存空间)

四、变量的声明和引用

name=\'egon\' #变量的声明
name #通过变量名,引用变量的值
print(name) #引用并且打印变量名name对应的值,即\'egon\'
name1=\'lhf\'
name2=\'egon\'

name1=\'lhf\'
name2=name1

注:变量名没有储藏值的作用,只起到绑定值的作用,改变一个变量的值,变量名重新指向一个值,原值物理地址不变。

常量

  • 常量即指不变的量,如圆周率 3.1415926..., 在Python中没有一个专门的语法代表常量,程序员约定俗成用变量名全部大写代表常量AREAS = 56

解释器

  1. 解释器:即时调试代码,代码无法永久保存

  2. 文件:永久保存代码

  在D:\\python_test\\目录下新建文件hello.py,编写代码如下

print(\'hello world\')

执行hello.py,即python D:\\python_test\\hello.py

python内部执行过程如下:

上一步中执行python D:\\python_test\\hello.py时,明确的指出 hello.py 脚本由 python 解释器来执行。

在linux平台中如果想要类似于执行shell脚本一样执行python脚本,例: ./hello.py ,那么就需要在 hello.py 文件的头部指定解释器,如下:

#!/usr/bin/env python #该行只对linux有效

print(\'hello world\')

ps:执行前需给予 hello.py 执行权限,chmod 755 hello.py

程序交互

python3中统一都是input,python2中有raw_input等同于python3的input,另外python2中也有input

1.res=input("python3: ").strip()

2.res=raw_input("python2: ")

3.res=input("python2: ")

1,2无论接收何种输入,都被存为字符串赋值给res,

3的意思是,用户输入何种类型,就以何种类型赋值给res

  • 在python3中 input:用户输入任何值,都存成字符串类型

1.1文件头

  #!/usr/bin/env python   #Linux系统下有效

  # -*- coding: utf-8 -*-

1.2注释

  注释当前行:#

  注释多行\'\'\'

      被注释内容

      \'\'\'

1.3执行脚本传入参数

Python有大量的模块,从而使得开发Python程序非常简洁。类库有包括三中:

  • Python内部提供的模块
  • 业内开源的模块
  • 程序员自己开发的模块

Python内部提供一个 sys 的模块,其中的 sys.argv 用来捕获执行执行python脚本时传入的参数

1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3   
4 import sys
5   
6 print sys.argv

执行

C:\\Users\\Administrator>python D:\\python_test\\hello.py arg1 arg2 arg3
[\'D:\\\\python_test\\\\hello.py\', \'arg1\', \'arg2\', \'arg3\']

1.4了解pyc文件

  执行Python代码时,如果导入了其他的 .py 文件,那么,执行过程中会自动生成一个与其同名的 .pyc 文件,该文件就是Python解释器编译之后产生的字节码。

  ps:代码经过编译可以产生字节码;字节码通过反编译也可以得到代码。

range

  • range用来指定范围,生成指定的数字。
1
2
3
4
5
6
7
for item in range(5,10,2):
    print(item)
"""
5
7
9
"""

基本数据类型

  • 数据即变量的值,变量的是用来反映/保持状态以及状态变化的,毫无疑问针对不同的状态就应该用不同类型的数据去标识

一、数字

  定义:a=1

  特性:

  1.只能存放一个值

  2.一经定义,不可更改

  3.直接访问

  分类:整型,长整型,布尔,浮点,复数

1.1整形

  • 定义:age=10 #age=int(10)
  • 用于标识:年龄,等级,身份证号,qq号,个数

  Python的整型相当于C中的long型,Python中的整数可以用十进制,八进制,十六进制表示。

>>> 10
10         --------->默认十进制
>>> oct(10)
\'012\'      --------->八进制表示整数时,数值前面要加上一个前缀“0”
>>> hex(10)
\'0xa\'      --------->十六进制表示整数时,数字前面要加上前缀0X或0x

python2.*与python3.*关于整型的区别

python2.*
 在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647
 在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807
  
 python3.*整形长度无限制

1.2长整形long

python2.*:
跟C语言不同,Python的长整型没有指定位宽,也就是说Python没有限制长整型数值的大小,但是实际上由于机器内存有限,所以我们使用的长整型数值不可能无限大。

在使用过程中,我们如何区分长整型和整型数值呢?

通常的做法是在数字尾部加上一个大写字母L或小写字母l以表示该整数是长整型的,例如:

a = 9223372036854775808L
注意,自从Python2起,如果发生溢出,Python会自动将整型数据转换为长整型,

所以如今在长整型数据后面不加字母L也不会导致严重后果了。

python3.*

长整型,整型统一归为整型

1.3布尔bool

  True 和 False

  1 和 0

1.4浮点数float

  • 定义:salary=3.1 #salary=float(3.1)
  • 用于标识:工资,身高,体重

Python的浮点数就是数学中的小数,类似C语言中的double。

在运算中,整数与浮点数运算的结果是浮点数

浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,

一个浮点数的小数点位置是可变的,比如,1.23*109和12.3*108是相等的。

浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,

就必须用科学计数法表示,把10用e替代,1.23*109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。

整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的而浮点数运算则可能会有四舍五入的误差。

1.5复数complex

复数由实数部分和虚数部分组成,一般形式为x+yj,其中的x是复数的实数部分,y是复数的虚数部分,这里的x和y都是实数。

注意,虚数部分的字母j大小写都可以。

>>> 1.3 + 2.5j == 1.3 + 2.5J
True

1.6数字相关内建函数

二、布尔

  • 判断一个条件成立时,用True标识,不成立则用False标识
  • *****None,0,空(空字符串,空列表,空字典等)三种情况下布尔值为False*****

三、字符串

  • 定义:name=\'tom\' #name=str(\'tom\')
  • 用于标识:描述性的内容,如姓名,性别,国籍,种族
  • 加了引号的字符就是字符串类型,单引号、双引号、多引号都一样,注意单双引号的嵌套

  定义:它是一个有序的字符的集合,用于存储和表示基本的文本信息,‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串
  特性:
  1.只能存放一个值
  2.不可变
  3.按照从左到右的顺序定义字符集合,下标从0开始顺序访问,有序
  补充:
  1.字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所有字符均取消特殊意义,在引号前面加r,如name=r\'l\\thf\'
  2.unicode字符串与r连用必需在r前面,如name=ur\'l\\thf\'

1
2
3
4
5
6
7
8
s = "watch ,\'套路\'"
#多行字符串必须用多引号
msg = \'\'\'
种一棵树最好的时间是十年前,其次是现在。
所有的成功都是你行动以后对你行动的奖励。
\'\'\'
print(s)  #watch ,\'套路\'
print(msg)

1、字符串常用操作

  res=\'hello world          \'

  移除空白 

res=\'hello world      \'
print(res.strip())

hello world  #移除字符串后面的空白

  分割

print(res.split())
[\'hello\', \'world\']

  长度

res=\'hello world      \'
print(len(res))

17

  索引

res=\'hello world      \'
print(res[4])

o

  切片

res=\'hello world      \'
print(res[1:4])

ell

字符串中的搜索和替换:

S.find(substr, [start, [end]])     #返回S中出现substr的第一个字母的标号,如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索 
S.index(substr, [start, [end]])     #与find()相同,只是在S中没有substr时,会返回一个运行时错误 
S.rfind(substr, [start, [end]])     #返回S中最后出现的substr的第一个字母的标号,如果S中没有substr则返回-1,也就是说从右边算起的第一次出现的substr的首字母标号 
S.rindex(substr, [start, [end]]) 
S.count(substr, [start, [end]])      #计算substr在S中出现的次数 
S.replace(oldstr, newstr, [count])      #把S中的oldstr替换为newstr,count为替换次数。这是替换的通用形式,还有一些函数进行特殊字符的替换 
S.strip([chars])   #把S中前后chars中有的字符全部去掉,可以理解为把S前后chars替换为None

注:可用于判断字符串是否为空,字符串为空返回False,不为空时返回Ture。

S.lstrip([chars])   #把S中前chars中有的字符去掉
S.rstrip([chars])   #把S中后chars中有的字符全部去掉
S.expandtabs([tabsize])     #把S中的tab字符替换没空格,每个tab替换为tabsize个空格,默认是8个

字符串的分割和组合:

S.split([sep, [maxsplit]])   #以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 
S.rsplit([sep, [maxsplit]]) 
S.splitlines([keepends])   #把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符。 
S.join(seq)   #把seq代表的序列──字符串序列,用S连接起来
字符串的mapping,这一功能包含两个函数:
String.maketrans(from, to)   #返回一个256个字符组成的翻译表,其中from中的字符被一一对应地转换成to,所以from和to必须是等长的。 
S.translate(table[,deletechars])   # 使用上面的函数产后的翻译表,把S进行翻译,并把deletechars中有的字符删掉。需要注意的是,如果S为unicode字符串,那么就不支持 deletechars参数,可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译 表。

字符串中字符大小写的变换:

S.lower()     #小写 
S.upper()     #大写 
S.swapcase()     #大小写互换 
S.capitalize()     #首字母大写 
String.capwords(S)    #这是模块中的方法。它把S用split()函数分开,然后用capitalize()把首字母变成大写,最后用join()合并到一起
S.title()      #只有首字母大写,其余为小写,模块中没有这个方法

字符串的测试函数

这些函数返回的都是bool值

S.starstwith(prefix[,start[,end]])   #是否以prefix开头 
S.endswith(suffix[,start[,end]])    #以suffix结尾 
S.isalnum()    #是否全是字母和数字,并至少有一个字符 
S.isalpha()    #是否全是字母,并至少有一个字符 
S.isdigit()    #是否全是数字,并至少有一个字符 
S.isspace()   #是否全是空白字符,并至少有一个字符 
S.islower()   #S中的字母是否全是小写 
S.isupper()   #S中的字母是否便是大写 
S.istitle()   #S是否是首字母大写的

字符串在输出时的对齐:

S.ljust(width,[fillchar])     #输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。 
S.rjust(width,[fillchar])      #右对齐 
S.center(width, [fillchar])      #中间对齐 
S.zfill(width)     #把S变成width长,并在右对齐,不足部分用0补足

格式化字符串:

s=\'name:{},age:{},sex:{}\'

print(s.format(\'ogen\',18,\'male\',\'asdasda\'))#多余的参数不会影响结果,少参数会报错。

四、列表

定义:[]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素。
特性:
1.可存放多个值。
2.可修改指定索引位置对应的值,可变。
3.按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序。

1、列表创建

list_test=[\'lhf\',12,\'ok\']

list_test=list(\'abc\')

list_test=list([\'lhf\',12,\'ok\'])

2、列表常用操作

>>> classmates = [\'Michael\', \'Bob\', \'Tracy\']
>>> classmates
[\'Michael\', \'Bob\', \'Tracy\']

索引

>>> classmates[0]
\'Michael\'
>>> classmates[1]
\'Bob\'
>>> classmates[2]
\'Tracy\'
>>> classmates[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> classmates[-1]
\'Tracy\'

切片

>>> classmates[0:]
[\'Michael\', \'Bob\', \'Tracy\']
>>> classmates[0::2]
[\'Michael\', \'Tracy\']
>>> classmates[:2]
[\'Michael\', \'Bob\']
>>> classmates[-2:-1]
[\'Bob\']
>>> classmates[-2:0]
[]
>>> classmates[-3:-1]
[\'Michael\', \'Bob\']

追加

>>> classmates.append(\'Adam\')
>>> classmates
[\'Michael\', \'Bob\', \'Tracy\', \'Adam\']
>>> classmates.insert(1, \'Jack\')
>>> classmates
[\'Michael\', \'Jack\', \'Bob\', \'Tracy\', \'Adam\']

删除

>>> classmates.pop()
\'Adam\'
>>> classmates
[\'Michael\', \'Jack\', \'Bob\', \'Tracy\']
>>> classmates.pop(1)
\'Jack\'
>>> classmates
[\'Michael\', \'Bob\', \'Tracy\']

长度

>>> len(classmates)
3

循环

>>> for i in classmates:
...     print(i)
...
Michael
Bob
Tracy

包含

>>> \'Bob\' in classmates
True
>>> \'ogen\' in classmates
False
1
2
students_info=[[\'tom\',18,[\'sing\',]],[\'rose\',18,[\'play\',\'sleep\']]]
print(students_info[0][2][0]) #取出第一个学生的第一个爱好 #sing

五、元组

定义:与列表类似,只不过[]改成()
特性:

1.可存放多个值。
2.不可变。
3.按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序。

1、元组创建

ages = (11, 22, 33, 44, 55)

ages = tuple((11, 22, 33, 44, 55))

定义一个空的元组 t=()

定义只有1个元素的元组

t=(1) 这样t的类型就是整形

t=(1,) 这样t的类型就是元组

一个“可变的”tuple:

>>> t = (\'a\', \'b\', [\'A\', \'B\'])
>>> t[2][0] = \'X\'
>>> t[2][1] = \'Y\'
>>> t
(\'a\', \'b\', [\'X\', \'Y\'])

定义的时候tuple包含的3个元素:

tuple-0

当我们把list的元素\'A\'\'B\'修改为\'X\'\'Y\'后,tuple变为:

tuple-1

表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向\'a\',就不能改成指向\'b\',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

2、元组的操作

索引

>>> ages = (11, 22, 33, 44, 55)
>>> ages[0]
11

切片

>>> ages[0:]
(11, 22, 33, 44, 55)
>>> ages[0:3]
(11, 22, 33)
>>> ages[:3]
(11, 22, 33)
>>> ages[:3:2]
(11, 33)
>>> ages[-3:-1]
(33, 44)

循环

>>> for i in ages:
...     print(i)
...
11
22
33
44
55

包含

>>> 11 in ages
True
>>> 12 in ages
False

六、字典

定义:{key1:value1,key2:value2},key-value结构,key必须可hash
特性:

1.可存放多个值。
2.可修改指定key对应的值,可变。
3.无序。

1、字典的创建

 person = {"name": "sb", \'age\': 18}


person = dict(name=\'sb\', age=18)
person = dict({"name": "sb", \'age\': 18})
person = dict(([\'name\',\'sb\'],[\'age\',18]))
{}.fromkeys(seq,100) #不指定100默认为None

注意:

>>> dic={}.fromkeys([\'k1\',\'k2\'],[])
>>> dic
{\'k1\': [], \'k2\': []}
>>> dic[\'k1\'].append(1)
>>> dic
{\'k1\': [1], \'k2\': [1]}

2、字典的操作

索引

>>> d = {\'Michael\': 95, \'Bob\': 75, \'Tracy\': 85}
>>> d[\'Michael\']
95

新增

>>> d[\'alex\']=100
>>> d
{\'Michael\': 95, \'Bob\': 75, \'Tracy\': 85, \'alex\': 100}

如果key不存在,就会报错。

避免key不存在的错误,有两种判断key是否存在的方式

1.通过in判断:

>>> \'Thomas\' in d
False

2.通过get()判断,如果key不存在,可以返回None,或者自己指定的value:

>>> d.get(\'Thomas\')
>>> d.get(\'Thomas\', -1)
-1

删除

>>> d.pop(\'Bob\')
75
>>> d
{\'Michael\': 95, \'Tracy\': 85}

循环

>>> for i in d:
...     print(i,d[i])
...
Michael 95
Bob 75
Tracy 85
alex 100

长度

>>> len(d)
4

请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较,dict有以下几个特点:

  1. 查找和插入的速度极快,不会随着key的增加而变慢;
  2. 需要占用大量的内存,内存浪费多。

而list相反:

  1. 查找和插入的时间随着元素的增加而增加;
  2. 占用空间小,浪费内存很少。

所以,dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象

这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。

要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key:

3、字典的常用函数

.pop(key,\'str\')    删除key对应的键值对,返回value。key不存在返回str。

.popitem()       随机删除键值对

.keys()        返回字典的所有key到dict_keys中。可以使用list(d.keys())

.values()      返回字典的valu到dict_values中,可以使用list(d.keys())

.items()     返回键值对。

.get(key,\'str\')  返回key对应的值value,key不存在返回自定义的str。

.clear()      清空字典

.copy()      复制字典

{}.fromkeys([],None)  初始化字典

.update(dict)     将新字典ditct更新到原字典中,键存在覆盖值,键不存在创建键值对   

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
info={
    \'name\':\'tom\',
    \'hobbies\':[\'sing\',\'sleep\'],
    \'company\':{
        \'name\':\'google\',
        \'type\':\'it\',
        \'fund\':8000000000,
    }
}
print(info[\'company\'][\'fund\']) #取公司现金储备 #8000000000
 
students=[
    {\'name\':\'tom\',\'age\':18,\'hobbies\':[\'sing\',\'play\']},
    {\'name\':\'rose\',\'age\':88,\'hobbies\':[\'read\',\'sleep\']},
    {\'name\':\'jack\',\'age\':99,\'hobbies\':[\'swim\',\'watchTV\',\'talk\']},
]
print(students[2][\'hobbies\'][1]) #取第3个学生的第2个爱好watchTV

流程控制之if...else

1
2
3
4
5
6
7
8
9
10
11
12
"""
rose --> 超级管理员
tom  --> 普通管理员
其他 --> 普通用户
"""
name = input(\'请输入用户名字:\').strip()
if name == \'rose\':
    print(\'超级管理员\')
elif name == \'tom\':
    print(\'普通管理员\')
else:
    print(\'普通用户\')

流程控制之while循环

一、条件循环

1
2
3
4
5
count=0
while count <= 10:
    if count%2 == 0:
        print(\'loop\',count)
    count+=1

二、死循环

1
2
while True:
    print(\'hello world\')

三、循环嵌套与tag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
name=\'tom\'
password=\'123\'
 
tag=True
while tag:
    inp_name=input(\'用户名: \').strip()
    inp_pwd=input(\'密码: \').strip()
    if inp_name == name and inp_pwd == password:
        while tag:
            cmd=input(\'>>: \')
            if not cmd:continue
            if cmd == \'q\':

(c)2006-2024 SYSTEM All Rights Reserved IT常识