python学习笔记

strings = ('puppy', 'kitten', 'puppy', 'puppy',
           'weasel', 'puppy', 'kitten', 'puppy')
counts = {}

for kw in strings:
    if kw not in counts:
        counts[kw] = 1
    else:
        counts[kw] += 1

# counts:
# {'puppy': 5, 'weasel': 1, 'kitten': 2}

也可以通过dict.setdefault()方法来设置默认值：
strings = ('puppy', 'kitten', 'puppy', 'puppy',
           'weasel', 'puppy', 'kitten', 'puppy')
counts = {}

for kw in strings:
    counts.setdefault(kw, 0)
    counts[kw] += 1

使用collections.defaultdict类

defaultdict类就好像是一个dict，但是它是使用一个类型来初始化的：

>>> from collections import defaultdict
>>> dd = defaultdict(list)
>>> dd
defaultdict(<type 'list'>, {})

defaultdict类的初始化函数接受一个类型作为参数，当所访问的键不存在的时候，可以实例化一个值作为默认值：

需要注意的是，这种形式的默认值只有在通过dict[key]或者dict.__getitem__(key)访问的时候才有效

from collections import defaultdict

strings = ('puppy', 'kitten', 'puppy', 'puppy',
           'weasel', 'puppy', 'kitten', 'puppy')
counts = defaultdict(lambda: 0)  # 使用lambda来定义简单的函数

for s in strings:
    counts[s] += 1

14 shape 函数，以及shape(2,)和shape（2，1）区别

>>> import numpy as np
>>> x = np.array([1, 2])
>>> y = np.array([[1],[2]])
>>> z = np.array([[1,2]])
>>> print(x.shape)
(2,)
>>> print(y.shape)
(2, 1)
>>> print(z.shape)
(1, 2)

x[1,2]的shape值(2,)，意思是一维数组，数组中有2个元素

y[[1],[2]]的shape值是(2,1)，意思是一个二维数组，每行有1个元素

z [[1,2]]的shape值是（1，2），意思是一个二维数组，每行有2个元素

15 数据拼接之concatenate()和append对比

concatenate()效率更高，适合大规模的数据拼接

numpy提供了numpy.concatenate((a1,a2,...), axis=0)函数。能够一次完成多个数组的拼接。其中a1,a2,...是数组类型的参数

>>> a=np.array([1,2,3])
>>> b=np.array([11,22,33])
>>> c=np.array([44,55,66])
>>> np.concatenate((a,b,c),axis=0)  # 默认情况下，axis=0可以不写
array([ 1,  2,  3, 11, 22, 33, 44, 55, 66]) #对于一维数组拼接，axis的值不影响最后的结果

>>> a=np.array([[1,2,3],[4,5,6]])
>>> b=np.array([[11,21,31],[7,8,9]])
>>> np.concatenate((a,b),axis=0)
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [11, 21, 31],
       [ 7,  8,  9]])

>>> np.concatenate((a,b),axis=1)  #axis=1表示对应行的数组进行拼接
array([[ 1,  2,  3, 11, 21, 31],
       [ 4,  5,  6,  7,  8,  9]])

说明：numpy.append()和numpy.concatenate()两个函数的运行时间进行比较，concatenate明显比append快。

16 PYTHON SOCKET编程详细介绍

服务端：

__author__ = "Alex Li"

#-*-coding:utf-8-*-
#服务器端

import socket
server = socket.socket()
server.bind(('localhost',6969)) #绑定要监听端口
server.listen(5) #监听

print("我要开始等电话了")
while True:
    conn, addr = server.accept()  # 等电话打进来
    # conn就是客户端连过来而在服务器端为其生成的一个连接实例
    print(conn, addr)
    print("电话来了")
    count = 0
    while True:
        data = conn.recv(1024)
        print("recv:",data)
        if not data:
            print("client has lost...")
            break
        conn.send(data.upper())
        count+=1
        if count >10:break

server.close()

客户端:

__author__ = "Alex Li"
#客户端
import socket

client = socket.socket() #声明socket类型，同时生成socket连接对象
client.connect(('localhost',6969))

while True:
    msg = input(">>:").strip()
    if len(msg) == 0:continue
    client.send(msg.encode("utf-8"))
    data = client.recv(10240)
    print("recv:",data.decode())

client.close()

python中datafram直接赋值是引用

python 中if-else的多种简洁的写法

if-else简洁的写法4种：

第1种:__就是普通写法

a, b, c = 1, 2, 3
if a>b:

    c = a

else:

    c = b

第二种：一行表达式,为真时放if前

c = a if a>b else b

第三种：二维列表，利用大小判断的0，1当作索引

c= [b, a][a > b]

第四种：传说中的黑客，利用逻辑运算符进行操作，都是最简单的东西，却发挥无限能量啊

c = (a>b and [a] or [b])[0]
# 改编版
c = (a>b and a or b)

第四种最有意思了，

利用and 的特点，若and前位置为假则直接判断为假。

利用 or的特点，若or前位置为真则判断为真。

浅拷贝与深拷贝

相关参考：https://blog.csdn.net/hlg1995/article/details/80330628

一、浅拷贝（指向同一块数据）

>>> import numpy as np
>>> a = np.arange(4)
>>> b = a
>>> a[0] = 11
>>> a
array([11, 1, 2, 3])
>>> b
array([11, 1, 2, 3])
>>> b is a
True
>>> c = b
>>> c is a
True
>>>

二、深拷贝.copy()

>>> import numpy as np
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> b = a.copy()
>>> a[0:4] = [11,22,33,44]
>>> a
array([11, 22, 33, 44])
>>> b
array([0, 1, 2, 3])
>>>

copy.copy 浅拷贝只拷贝父对象，不会拷贝对象的内部的子对象。
copy.deepcopy 深拷贝拷贝对象及其子对象

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象

b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝

a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象

print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
输出结果：
a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c =  [1, 2, 3, 4, ['a', 'b', 'c']]
d =  [1, 2, 3, 4, ['a', 'b']]

numpy.random.seed()使用有效性

random.seed()仅第一次使用有效

seed( ) 用于指定随机数生成时所用算法开始的整数值，如果使用相同的seed( )值，则每次生成的随即数都相同，如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同。

编写如下第一份代码：from numpy import *

num=0
while(num<5):
    random.seed(5)
    print(random.random())
    num+=1

运行结果为：

0.22199317108973948
0.22199317108973948
0.22199317108973948
0.22199317108973948
0.22199317108973948

可以看到，每次运行的结果都是一样的

修改代码，如下为第二份代码：

from numpy import *
num=0
random.seed(5)
while(num<5):
    print(random.random())
    num+=1

运行结果为：

0.22199317108973948
0.8707323061773764
0.20671915533942642
0.9186109079379216
0.48841118879482914

总结：

seed( ) 用于指定随机数生成时所用算法开始的整数值。
1.如果使用相同的seed( )值，则每次生成的随即数都相同；
2.如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同。
3.设置的seed()值仅一次有效

前端HTML后端传递参数(GET_POST)

a flying bird

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录