python代码大全和用法,python基础代码讲解

本篇文章给大家谈谈python代码大全和用法，以及python基础代码讲解，希望对各位有所帮助，不要忘了收藏本站喔。

1. 文件操作
请通过键盘依次输入每位同学的学号、姓名、性别、身高、体重，并保存在c:\student.txt文件中，每位同学一行。程序运行过程如下：
学号: 100
姓名: zhangsan
性别: 男
身高: 175
体重: 72
学号: 200
姓名: lisi
性别: 女
身高: 168
体重: 55
保存之后的文件内容如下：
100 zhangsan 男 175 72
200 lisi 女 168 55
请通过键盘输入学号，在刚才保存的c:\student.txt文件中，查询相应的学生，输出ta的身高python六瓣花的画法。运行过程如下：
学号: 100
175

def select():
    with open('info.txt','r') as f:
        no=input('查询的学号')
        content=f.readlines()
        for each in content:
            temp=each.split()
            if no==temp[0]:
                print(temp[3])
                break
def add():
    with open('info.txt','a') as f:
        myinput=[]
        info=['学号','姓名','性别','身高','体重']
        for i in range(5):
            myinput.append(input('%s'%info[i]))
        for each in myinput:
            f.write(each+' ')
        f.write('\n')

2. 请把第1题修改成使用sqlite3数据库。具体来说就是这样： 首先在sqlite3数据库中创建学生信息表，包括学号、姓名、性别、身高、体重五个字段。
然后运行你的程序，过程与上次一样，只是保存的时候通过insert语句保存到刚刚创建的数据库中。
查询过程也类似，通过执行select语句实现查找功能

import sqlite3

def create():
    conn=sqlite3.connect('test.db')
    cu=conn.cursor()
    cu.execute('create table stuinfo if not exit(no varchar(10) primary key,name varchar(20),sex varchar(20),height varchar(20),weight varchar(20))')
    cu.close()
    conn.commit()
    conn.close()
def add():
    conn=sqlite3.connect('test.db')
    cu=conn.cursor()
    myinput=[]
    info=['学号','姓名','性别','身高','体重']
    for i in range(5):
        myinput.append(input('%s'%info[i]))
    cu.execute('insert into stuinfo values(?,?,?,?,?)',(myinput[0],myinput[1],myinput[2],myinput[3],myinput[4]))
    cu.close()
    conn.commit()
    conn.close()
def select(no):
    conn=sqlite3.connect('test.db')
    cu=conn.cursor()
    a=cu.execute('select height from stuinfo where id=?',(no,))
    vlaue=a.fetchall()
    print(vlaue[0][0])
    cu.close()
conn.close()

3. 请编写myqq即时聊天脚本。具体来说，就是两个同学一组，各自在自己的电脑上面运行python脚本，实现类似于qq的聊天功能。
提示1：使用udp协议
提示2：两个同学的程序是不一样的，一个是udp的server端，一个是udp的client端

客户端：

import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    msg=input('输入要发送的内容:')
    server_address=('127.0.0.1',9999)
    client.sendto(msg.encode(),server_address)
    receive_data,sender_address=client.recvfrom(1024)
    print('接收到了%s传来的数据:%s'%(sender_address,receive_data.decode()))

服务器端：

import socket

s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
address=('127.0.0.1',9999)
s.bind(address)
while True:
    data,addr=s.recvfrom(1024)
    print('收到的%s的数据:%s'%(addr,data.decode()))
    msg=input('输入发送的信息')
    s.sendto(msg.encode(),address)

4. 使用tcp协议编写满足如下要求的服务器端和客户端代码，客户端向服务器端发送以下两种格式的请求数据：
格式一：
GET filename
例如
GET 1.txt
服务器收到这种格式的请求之后，读取c:\homepages\目录下面指定filename文件（例如c:\homepage\1.txt）的内容，并按照如下约定返回响应数据：
如果文件存在，则返回两行内容：
200
c:\homepage\1.txt文件的内容
如果文件不存在，则返回下面两行内容：
404
file not found
格式二：
POST filename xxxxxx
服务器端收到这种请求之后，在c:\homepages\目录下面以指定filename创建文件，并写入xxxxxx的内容，如果文件存在，则追加写入。返回给客户端的数据如 下：
200
写入长度

客户端：

import socket

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',54321))
while True:
    temps1=input('发送内容')
    if temps1=='end':
        break
    s.send(temps1.encode())
    data=s.recv(1024).decode()
    print(data)
s.send(b'exit')
s.close()

服务器端：

import socket
import threading
import time

def tcplink(sock,addr):
    while True:
        data=sock.recv(1024)
        time.sleep(1)
        if not data or data.decode()=='exit':
            break
        elif data.decode()[0:4]=='GET ':
            templ1=[]
            templ1=data.decode().split()
            try:
                f=open(templ1[1],'r')
                sock.send(b'200\n'+templ1[1].encode()+f.read().encode())
                f.close()
            except OSError:
                sock.send(b'404\nfile not found')
        elif data.decode()[0:5]=='POST ':
            templ1=[]
            templ1=data.decode().split()
            f=open(templ1[1],'a')
            temp1=f.write(templ1[2])
            f.close()
            temps1=str(temp1)
            sock.send(b'200\n'+temps1.encode())
        else:
            sock.send('请输入正确格式请求'.encode())
    sock.close()

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('',54321))
s.listen(5)
while True:
    sock,addr=s.accept()
    t=threading.Thread(target=tcplink,args=(sock,addr))
    t.start()

5. 使用python编程实现上述过程（访问https://www.51job.com/，在搜索框输入关键字：python java，用右边的加号选择北京、上海、广州、深圳四个城市），不需要使用socket编程来做，使用书上提到的request库或者其它库都可以。

6. 网页返回的内容是html格式的，下面是经过简化之后的部分页面内容：

北京-朝阳区
1.5-2万/月
10-16
深圳-龙华新区
1.5-2.5万/月
10-16
北京-海淀区
0.8-1.5万/月
10-16
广州
1.5-2万/月
10-16
可以尝试用字符串比对的方式取出里面的数据部分，结果如下：
北京-朝阳区
1.5-2万/月
10-16
深圳-龙华新区
1.5-2.5万/月
10-16
北京-海淀区
0.8-1.5万/月
10-16
广州
1.5-2万/月
10-16

7. 了解正则表达式，使用正则表达式解决6的问题。

 

8. 21.修改18的代码，分别获取关键字是python、java，右边选择北京、上海、广州、深圳四个城市时前10页的招聘数据，用正则表达式解析获取的数据，按照以下格式分别把数据存储在文件和数据库中

关键字 工作地点 薪资min 薪资max
java 上海 1.5 1.6
java 深圳 1.5 3
java 上海 0.8 1
python 北京 1.5 2.5
python 广州 1.5 2.2
提示：网页上的数据有两处需要处理：
一是工作地点，原始内容可能是上海-浦东新区，只保留前面的城市名上海
二是薪资，原始内容是1.2-1.8万/月或10-20万/年，把单位换算成一致的，并且把最小值和最大值分开存放

import urllib.request
import re
import sqlite3

def get_content(page, key):
    url = 'https://search.51job.com/list/010000%252C020000%252C030200%252C040000,000000,0000,00,9,99,' + key + ',2,' + str(page) + '.html'
    a = urllib.request.urlopen(url)
    html = a.read().decode('gbk')
    lst = re.findall(r'<span class="t3">(北京|上海|广州|深圳).*?</span>\s+<span class="t4">(\d+\.?\d?)-(\d+\.?\d?)(万|千)/(年|月)</span>', html)
    return lst

conn = sqlite3.connect('51.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS jobs
        (key text, addr text, min float, max float)''')
c.execute('''delete from jobs''')
conn.commit()

with open('51.txt', 'w') as f:
    f.write('%s\t%s\t%s\t%s\n' % ('key','addr','min','max'))
    for key in ('python', 'java'):
        for each in range(1, 11):
            for items in get_content(each, key):
                min = float(items[1])
                max = float(items[2])
                if items[3] == "千":
                    min /= 10
                    max /= 10
                if items[4] == "年":
                    min /= 12
                    max /= 12
                f.write('%s\t%s\t%s\t%s\n' % (key, items[0], round(min, 2), round(max, 2)))
                c.execute("INSERT INTO jobs VALUES (?,?,?,?)", (key, items[0], round(min, 2), round(max, 2)))
conn.commit()
conn.close()

if __name__ == '__main__':
    lst = get_content(1, 'python')
print(lst)

9. 分析爬取下来的51job上的信息，给出java 最小工资=10000，应该去哪个城市，利用贝叶斯分类

方法一：pandas：

import pandas as pd
df = pd.read_csv('51.txt', sep='\t')

# 计算类别的先验概率

pc = df['addr'].value_counts() / df['addr'].size

# 计算每个特征属性条件概率

pa = pd.crosstab(df['addr'], df['key'], margins=True).apply(lambda x:x/x[-1], axis=1)

# 通过样本计算出均值和方差，也就是得到正态分布的密度函数。有了密度函数，就可以把值代入，算出某一点的密度函数的值

import numpy as np
df2 = df.groupby('addr').agg([np.mean, np.var])
df2['x'] = 1

from math import pi, exp, sqrt
def f(x, mean, var):
    return exp(-(x-mean)**2/(2*var))/sqrt(2*pi*var)

df2['p_x_min']=df2[['min','x']].apply(lambda x: f(x['x'], x['min']['mean'], x['min']['var']), axis=1)
df2['p_x_max']=df2[['max','x']].apply(lambda x: f(x['x'], x['max']['mean'], x['max']['var']), axis=1)

(df2['p_x_min']*pc*pa['java']).argmax()


方法二：
from numpy import genfromtxt
x = genfromtxt('51.txt', delimiter='\t', skip_header=True, usecols=(2,3))
x.shape
y = genfromtxt('51.txt', delimiter='\t', skip_header=True, usecols=(1), dtype=str)
y.shape
import numpy as np
np.unique(y)
from sklearn.naive_bayes import GaussianNB
clf = GaussianNB()
#拟合数据
clf.fit(x, y)
print(clf.predict([[0.8, 1.2]]))
print(clf.predict_proba([[0.8, 1.2]]))
print(clf.predict_log_proba([[0.8, 1.2]]))

10.线性回归解决给出身高生成体重问题：y=ax+b
用到的代码和数据hwSimulate.py是用于生成模拟数据的，大家运行一下会生成一个hw.txt
linear_regression.py包括自己实现的代码和用sklearn实现的
大家看着再学习一下

hwSimulate.py:

import random
with open('hw.txt', 'w') as f:
    f.write('height\tweight\n')
    for i in range(100):
        height = random.randint(1600, 1900) / 10
        weight = (height - 100) * 0.9 + random.randint(-50, 50) / 10
        f.write('%.1f\t%.1f\n' % (height, weight))

linear_regression.py:
__author__ = 'DivinerShi'
import numpy as np
import matplotlib.pyplot as plt

def compute_error(b,m,data):

    totalError = 0
    #Two ways to implement this
    #first way
    # for i in range(0,len(data)):
    #     x = data[i,0]
    #     y = data[i,1]

    #     totalError += (y-(m*x+b))**2
        # print('(%f*%f+%f)=%f,y=%f,loss=%f,totalError=%f' % (m,x,b,(m*x+b),y,(y-(m*x+b))**2,totalError))

    #second way
    x = data[:,0]
    y = data[:,1]
    totalError = (y-m*x-b)**2
    totalError = np.sum(totalError,axis=0)

    return totalError/float(len(data))

def optimizer(data,starting_b,starting_m,learning_rate,num_iter):
    b = starting_b
    m = starting_m

    #gradient descent
    for i in range(num_iter):
        #update b and m with the new more accurate b and m by performing
        # thie gradient step
        b,m =compute_gradient(b,m,data,learning_rate)
        if i%100==0:
            print('iter {0}:error={1}'.format(i,compute_error(b,m,data)))
    return [b,m]

def compute_gradient(b_current,m_current,data ,learning_rate):

    b_gradient = 0
    m_gradient = 0

    N = float(len(data))
    #Two ways to implement this
    #first way
    # for i in range(0,len(data)):
    #     x = data[i,0]
    #     y = data[i,1]
    
    #     #computing partial derivations of our error function
    #     #b_gradient = -(2/N)*sum((y-(m*x+b))^2)
    #     #m_gradient = -(2/N)*sum(x*(y-(m*x+b))^2)
    #     b_gradient += -(2/N)*(y-((m_current*x)+b_current))
    #     m_gradient += -(2/N) * x * (y-((m_current*x)+b_current))
    #     # print('m_current=%f,b_current=%f,N=%f,x=%f,y=%f,y-((m_current*x)+b_current)=%f, b_gradient=%f, m_gradient=%f' % (m_current, b_current, N, x, y, y-((m_current*x)+b_current), b_gradient, m_gradient))

    #Vectorization implementation
    x = data[:,0]
    y = data[:,1]
    b_gradient = -(2/N)*(y-m_current*x-b_current)
    b_gradient = np.sum(b_gradient,axis=0)
    m_gradient = -(2/N)*x*(y-m_current*x-b_current)
    m_gradient = np.sum(m_gradient,axis=0)
        
    #update our b and m values using out partial derivations
    new_b = b_current - (learning_rate * b_gradient)
    new_m = m_current - (learning_rate * m_gradient)
    return [new_b,new_m]


def Linear_regression():
    # get train data
    # data =np.loadtxt('data.csv',delimiter=',')
    data =np.loadtxt('hw.txt',delimiter='\t',skiprows=True)

    #define hyperparamters
    #learning_rate is used for update gradient
    #defint the number that will iteration
    # define  y =mx+b
    learning_rate = 0.000001
    initial_b =0.0
    initial_m = 0.0
    num_iter = 10000

    #train model
    #print b m error
    print('initial variables:\n initial_b = {0}\n intial_m = {1}\n error of begin = {2} \n'\
        .format(initial_b,initial_m,compute_error(initial_b,initial_m,data)))

    #optimizing b and m
    [b ,m] = optimizer(data,initial_b,initial_m,learning_rate,num_iter)

    #print final b m error
    print('final formula parmaters:\n b = {1}\n m={2}\n error of end = {3} \n'.format(num_iter,b,m,compute_error(b,m,data)))

    #plottting
    x = data[:,0]
    y = data[:,1]
    y_predict = m*x+b
    plt.scatter(x, y, color = 'blue')
    plt.plot(x,y_predict,'k-', color = 'red', linewidth = 4)
    # plt.show()

    from sklearn import linear_model
    regr = linear_model.LinearRegression()
    regr.fit(x.reshape(-1,1), y)
    print(regr.coef_, regr.intercept_)

    plt.scatter(x, y, color = 'blue')
    plt.plot(x, regr.predict(x.reshape(-1,1)), color = 'orange', linewidth = 4)
    plt.show()

def lr_by_sklearn():
    from sklearn import linear_model
    data =np.loadtxt('hw.txt',delimiter='\t',skiprows=True)
    x = data[:,0]
    y = data[:,1]
    regr = linear_model.LinearRegression()
    regr.fit(x.reshape(-1,1), y)
    print(regr.coef_, regr.intercept_)

    # import pandas as pd
    # data = pd.read_csv('hw.txt', sep='\t')
    # regr.fit(data['height'].values.reshape(-1,1), data['weight'])
    # plt.scatter(data['height'], data['weight'], color = 'blue')
    # plt.plot(data['height'], regr.predict(data['height'].values.reshape(-1,1)), color = 'orange', linewidth = 4)
    # plt.show()

    plt.scatter(x, y, color = 'blue')
    plt.plot(x, regr.predict(x.reshape(-1,1)), color = 'orange', linewidth = 4)
    plt.show()

if __name__ =='__main__':

    Linear_regression()

# lr_by_sklearn()

PS:
Python Programming Tutorials
神经网络的例子