大学生就业

一、专业实习内容

1)python基础语法，数据类型及其操作，函数的语法结构

2)异常处理，文件操作

3)Matplotlib画图功能

4)无监督学习算法 K-MEANS算法 监督学习算法KNN算法

5)Python面向对象设计和爬虫

二、具体实习内容

1)python基础语法，数据类型及其操作：主要学习基础语法:分支结构，循环结构语句，元组，数组，字典等存储结构的基础语法和相互转化，和函数的语法结构：

name='杨满';

str1='中国高铁被外界誉为当代中国的“新四大发明”之一(新四大发明包括：高铁，扫码支付，共享单车，网上购物)，据悉，中国高铁-复兴号目前最高时速为350公里每小时，5年之内将提速30%达到()公里每小时，以更快的速度助力中国经济。新华社记者-()';

a=str1.find("最高时速为")

b=str1.find("公里每小时")

tisu=str1.find("提速")

tisu+=3;

dadao=str1.find("达到")

jizhe=str1.find("记者-(")

c=a+5

currentSpeed =int(str1[c:b])

currentRate=int(str1[tisu-1:dadao-1])

currentRate=currentRate/100;

newSpeend=currentSpeed+currentSpeed*currentRate;

newspeed=str(newSpeend)

str2=list(str1);

str2.(dadao+3,newspeed)

str2.(jizhe+5,name)

greatChina=''.join(str2)

print(greatChina)

2)异常处理和文件处理：

主要学习了异常处理的基础语法，和设置异常处理的原则，文件的读写

def fun_error():

print("请重新输入，您刚才输入的省份不存在")

def fun_error2():

print("算错了")

try:

prove['广西']

except KeyError:

fun_error()

try:

print(1/0)

except ZeroDivisionError:

fun_error2()

fun_error2()

f=open("ni.txt",'r',encoding='utf-8')

data=f.read()

print(data)

f.write("欢迎")

f.close()

3)matplotlib画图实现：

主要学习将数据展示位散点图和折线图的方法：

import matplotlib.pyplot as plt

import numpy as np

plt.rcParams['font.sans-serif'] = 'SimHei'

plt.rcParams['axes.unicode_minus'] = False

p1=plt.figure()

plt.title("杨满+2015080332096+1949,1956,1960年代乘客数据分析")

plt.xlabel("月份")

plt.ylabel("人数")

plt.xlim(1,13) # 设定x轴范围

plt.ylim((100, 650))

plt.xticks(np.arange(1, 13, step=1))

plt.yticks(np.arange(0, 650, step=50))

year_1949=(112,118,132,129,121,135,148,148,136,119,104,118)

year_1956=(284,277,317,313,318,313,318,374,413,405,355,306)

year_1960=(417,391,419,461,472,535,622,606,508,461,390,432)

plt.plot(year_1949,color='red',linewidth=4.0,linestyle='-.',marker='*',markersize=10)

plt.plot(year_1956,color='blue',linewidth=3.0,linestyle='--',marker='s',markersize=10)

plt.plot(year_1960,color='yellow',linewidth=2.0,linestyle=':',marker='^',markersize=10)

plt.legend(['1949年代','1956年代','1960年代'])

plt.savefig('d:/home1.png')

plt.show()

4)k-means算法 和k-nn算法

主要学习了非监督学习和监督学习中两个最基础的算法，了解了算法的编程思想和动手实现了算法：

K-means算法：

import matplotlib.pyplot as plt

import numpy as np

import random

from numpy import *

import math

#初始图

plt.rcParams['font.sans-serif'] = 'SimHei'

plt.rcParams['axes.unicode_minus'] = False

p1=plt.figure(figsize=(8,6),dpi=80)

plt.xlabel("平均消费周期")

plt.ylabel("每次消费金额")

plt.xlim(1,100) # 设定x轴范围

plt.ylim((0, 800))

# plt.xticks(np.arange(1, 100, step=1))

# plt.yticks(np.arange(0, 800, step=10))

x=[10,13,17,67,35,1,10,12,8,1,32,3,90,1,16,31,25]

y=[317,147,172,194,789,190,281,142,186,226,287,499,181,172,190,271,382]

plt.scatter(x, y)

#参数规定

k_number=3

x_random=[]

y_random=[]

dic=[]

result_x_num0=[]

result_y_num0=[]

result_x_num1=[]

result_y_num1=[]

result_x_num2=[]

result_y_num2=[]

#随机生成类聚中心点坐标

for i in range (0,k_number):

random_kid_x=random.randint(1,100)

x_random.append(random_kid_x)

random_kid_y=random.randint(0,800)

y_random.append(random_kid_y)

x_randomz_first=x_random#存放第一次聚类中心的x坐标

y_random_first=y_random#存放第一次聚类中心的y坐标

x_randomz_second=[0,0,0]#存放第二次聚类中心的x坐标

y_random_second=[0,0,0]#存放第二次聚类中心的y坐标

result_x_num0 = []#存放0号类的x的坐标

result_y_num0 = []#存放0号类的y的坐标

result_x_num1 = []#存放1号类的x的坐标

result_y_num1 = []#存放1号类的y的坐标

result_x_num2 = []#存放2号类的x的坐标

result_y_num2 = []#存放2号类的y的坐标

result_x=0

result_y=0

相关推荐

【Python培训 】从小白到大咖 打造Python精英人才

【Python入门免费课程】引领编程开发新趋势

#判断两次类聚中心点坐标

def random_kid_is_same(x_randomz_first,y_random_first,y_random_second,x_randomz_second):

if x_randomz_first==x_randomz_second and y_random_first==y_random_second :

a= False

else:

a=True

return a

a=random_kid_is_same(x_randomz_first,y_random_first,y_random_second,x_randomz_second)

print(a)

while a:

for i in range(0, len(x)):

for j in range(0, 3):

dic.append(math.sqrt((x[i] - x_randomz_first[j]) * (x[i] - x_randomz_first[j]) + (y[i] - y_random_first[j]) * (

y[i] - y_random_first[j])))#求距离

if dic[2] < dic[0] and dic[2] < dic[1]: # 2号距离最小

result_x_num2.append(x[i])

result_y_num2.append(y[i])

dic = []

elif dic[0] < dic[1] and dic[0] < dic[2]: # 0号距离最小

result_x_num0.append(x[i])

result_y_num0.append(y[i])

dic = []

elif dic[1] < dic[0] and dic[1] < dic[2]: # 1号最小

result_x_num1.append(x[i])

result_y_num1.append(y[i])

dic = []

for i_1 in range (0,len(result_x_num0)):#取0号类别里的数据

result_x+=result_x_num0[i_1]

#print(result_x_num0)

x_randomz_second.append(result_x/len(result_x_num0))

for i_3 in range (0,len(result_y_num0)):

result_y+=result_y_num0[i_3]

y_random_second.append(result_x/len(result_x_num0))

for i_2 in range (0,len(result_x_num1)):#取1号类别里的数据

result_x+=result_x_num1[i_2]

print(len(result_x_num1))

x_randomz_second.append(result_x /(len(result_x_num1)))

for i_4 in range (0,len(result_y_num1)):

result_y+=result_y_num1[i_4]

y_random_second.append(result_y/len(result_y_num1))

for i_5 in range(0, len(result_x_num2)):#取2号类别里的数据

result_x += result_x_num2[i_5]

x_randomz_second.append(result_x / len(result_x_num2))

for i_6 in range(0, len(result_y_num2)):

result_y += result_y_num2[i_6]

y_random_second.append(result_y / len(result_y_num2))

a=random_kid_is_same(x_randomz_first,y_random_first,y_random_second,x_randomz_second)

x_randomz_first=x_randomz_second

y_random_first=y_random_second

plt.scatter(result_x_num0,result_y_num0,color=&#39;black&#39;)

plt.scatter(result_x_num1,result_y_num1,color=&#39;red&#39;)

plt.scatter(result_x_num2,result_y_num2,color=&#39;green&#39;)

plt.legend([&#39;第一类&#39;,&#39;第二类&#39;,&#39;第三类&#39;])

plt.savefig(&#39;d:/home2.png&#39;)

plt.show()

Knn算法：

import matplotlib.pyplot as plt

import numpy as np

import random

from numpy import *

import math

#编程逻辑：

# 将原始的数据所有的属性分开存在数组中，顺序一致，将要配置的电影的信息都存在一个数组里，

# 用欧式公式求出相似度，将电影名称和相似度存放在字典里，对字典进行排序(从小到大)，

# 然后按照排序出的结果根据电影名称查找每个电影对应的类型名称，将所有类型名称存在一个数组里

# 然后查找每种类型名称出现的次数，将类型名称和次数存放在字典里，在对字典进行排序(从大到小)

# 取出第一个数据的电影类型为要所求的电影类型，将此类型添加到要求的电影信息数组中

#数据准备

fill_name=[&#39;宝贝当家&#39;,&#39;美人鱼&#39;,&#39;澳门风云3&#39;,&#39;功夫熊猫3&#39;,&#39;谍影重重&#39;,&#39;叶问3&#39;,&#39;我的特工爷爷&#39;,&#39;奔爱&#39;,&#39;夜孔雀&#39;,&#39;代理情人&#39;,&#39;新步步惊心&#39;,&#39;伦敦沦陷&#39;]

funny_lens=[45,21,54,39,5,3,6,7,9,9,8,2]

hug_lens=[2,17,9,0,2,2,4,46,39,38,34,3]

fighting_lens=[9,5,11,31,57,65,21,4,8,2,17,55]

fill_type=[&#39;喜剧片&#39;,&#39;喜剧片&#39;,&#39;喜剧片&#39;,&#39;喜剧片&#39;,&#39;动作片&#39;,&#39;动作片&#39;,&#39;动作片&#39;,&#39;爱情片&#39;,&#39;爱情片&#39;,&#39;爱情片&#39;,&#39;爱情片&#39;,&#39;动作片&#39;]

fill_need_name=[&#39;唐人街探案&#39;,23,3,17]

#参数规定

k_numebr=4

result={}

dict={}

dict_result={}

dic=0

type_name=[]

count_fight=0

count1_fun=0

count1_love=0

#求出要求的电影的属性和样本点求距离

for i in range(0,len(fill_name)):

dic= math.sqrt((fill_need_name[1]-funny_lens[i])**2+(fill_need_name[2]-hug_lens[i])**2+(fill_need_name[3]-fighting_lens[i])**2)

result[fill_name[i]]=dic

#将数列排序 按value的值从小到大进行排序 给dict 此时dict的类型为list- list里的每一个元素为元组类型

dict= sorted(result.items(), key=lambda d:d[1], reverse = False)

print("相似度排序：-----------------")

for i in range (0,k_numebr):#按照要求k值进行截取

a=list(dict[i])#dict为list型 但是list中每一个元素为元组型，需要再转换为list型

print(a)#打印出按从小带大的排序取前k个

#按照电影名称查找每个电影的类型

for j in range(0,len(fill_name)):

if fill_name[j]==a[0]:

type_name.append(fill_type[j])

#遍历出来的所有电影类型名称 查找每个电影的类型出现的次数 存放到字典里

for i in range (0,len(type_name)):

if type_name[i]==&#39;动作片&#39;:

count_fight+=1

elif type_name[i]==&#39;喜剧片&#39;:

count1_fun+=1

elif type_name[i]==&#39;爱情片&#39;:

count1_love+=1

dict_result[&#39;动作片&#39;]=count_fight

dict_result[&#39;喜剧片&#39;]=count1_fun

#print(type_name)

print("相似度前四个所对应的电影类型出现的次数-----------")

print(dict_result)

#将存放电影类型的字典按照出现次数的大小从大到小排列 此时dict_2为list型，list中每一个元素为元组型

dict_2= sorted(dict_result.items(), key=lambda d:d[1], reverse = True)

b=list(dict_2[0])#把list中第一个元组转换成数组 再取第一个数据为 所需要的类型

#print(b[0])

#将 找到的电影类型添加到原来电影信息的数组中

fill_need_name.append(b[0])

print("所求结果：-----------------")

print(fill_need_name)

5)python面向程序和爬虫

Python可以面向过程编程也可以面向对象编程，爬虫是从网页下载指定的格式的内容

class Human():

def __init__(self,name,age):

self._name=name

self._age=age

def talk(self):

print("Human can talk")

def display(self):

print(self._name+"-"+str(self._age))

def __str__(self):

return self._name+"-"+str(self._age)

def __repr__(self):

return self.__str__()

def getAge(self):

return self._age

def add_human(name,age):

s=Human(name,age)

return s

name=&#39;小刚&#39;

age=22

a=add_human(name,age)

print(a)

import urllib.request

import re

def get_html(url):

page=urllib.request.urlopen(url)

html=page.read()

return html

reg= r&#39;src=" (.+?\.jpg)" .width &#39;

reg_img=re.compile(reg)#编译

html=get_html(&#39;http://tieba.baidu.com/p/1753935195&#39;)

html=html.decode(&#39;utf-8&#39;)

imglist=reg_img.findall(html)

三、心得总结

在大数据和云计算快速的发展的今天，python以语法简单功能强大成为学习大数据的一个理想的编程语言，在用python语言编程的时候发现跟其他语言有着明显的区别，python简化在其他语言中相对复杂繁琐的语法结构，但是在集成开发软件中，python需要按照严格的格式编程，如java是以分号作为程序结束的标记，并不要求在编程中需要有格式要求，然后python集成工具中写程序需要按照格式编程，这点在刚开始编程是会找不清每个部分所对应的级别，会造成很多编程错误，而当熟悉这种格式要求时，发现python这种简洁的要求更加简化的编程过程，编程速度也会有很大提高，逻辑也会更加清晰

Python中的变量并不需要提前设定变量类型，系统是自动添加数据类型，所以在编程中，要把握准确很大变量的类型，尤其在和元组，数组，字典相互使用的时候要注意类型的变化

个人认为在python编程中最重要的一步是在进行编程时想明白每个数组是用什么数据类型进行存放，当确定好数据类型后，python以它简单强大的语法，会使编程变得更加效率和简单!

相关推荐

【Python培训 】从小白到大咖 打造Python精英人才

【Python入门免费课程】引领编程开发新趋势