我的Python学习之路02-附练习题

Python基础语法格式，表达式与声明

Python基础语法格式

# 缩进 PEP8   https://www.python.org/dev/peps/pep-0008/
# PEP是Python Enhancement Proposals的缩写。
# 一个PEP是一份为Python社区提供各种增强功能的技术规格，也是提交新特性，以便让社区指出问题，精确化技术文档的提案。

#分隔代码块:

title='weijichen.com';score=61

if title=='weijichen.com':
    print('welcome to weijichen.com')
    if score<60:
        pass
        
#模块
import random
# dir(random)

#帮助的使用
#dir,help,?,??,shift+tab,tab,相关Python的小抄
s1='china'
print(dir(s1))
print(s1.__doc__)
s1.rfind?

表达式与声明

#### statement声明
a='weijichen.com'#statement通常为赋值语句
b=100
c=a

#### expression表达式（通常有返回结果 ）

#值、变量和运算符共同组成的整体我们将其称为表达式。通常有值表达式、变量表达式、计算表达式、字符串表达式,
b,b+100,a+' is amazing',__builtins__

exec执行声明语句,eval执行表达式

exec('aaaa=7')
aaaa

输出结果为7

exec('aaa=7')#从字符串里执行一个声明语句
eval('aaa')#从字符串里执行一个表达式

输出结果为7

eval()函数和exec() 函数的区别：
eval() 函数只能计算单个表达式的值，而exec() 函数可以动态运行代码段。
eval() 函数可以有返回值，而exec()函数返回值永远为None。

参考文章：https://www.cnblogs.com/yangmingxianshen/p/7810496.html

关键字、标识符，标准操作符，名字，赋值与名字空间

Python中保留的关键字

import keyword
print(keyword.kwlist)

输出的结果为：

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’,
‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’,
‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’,
‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’,
‘while’, ‘with’, ‘yield’]

合法标识符

• 数字，下划线，字母构成
• 避开关键字
• 不能用数字开头

好的命名习惯让开发更有效率

• 变量，函数或方法:salary,houseworker,booksname
• 常量：INTEREST_RATES
• 类：BankAccount,Employee,Company,OrderedDict #骆峰命名法

名字与对象之间的建立引用与解除引用

我们可以使用=建立名字与对象之间的关联，用del 名字来解除这种关联

标准操作符

#算术运算符
a=100;b=3
a+b;a-b;a*b;a/b
a//b #取商
a%b #取余
a**2
a**0.5

#比较运算符  
if a==b:
    print ('a equal b')

if a!=b:
    print ('a not equal b')
    
#逻辑运算符><>=,
if a>=50:
    print('a is grater than 50')
    
#成员运算符in,not in
websiteUrl='weijichen.com'
if '.net' not in websiteUrl:
    print ('.net not in it')
    

#多重赋值
#a=100;b=100
a=b=100

#多元赋值
#a=100;b=200
a,b,c=100,200,200

#交换赋值
a,b=b,a
print(a,b)

#unpack解包
l1=[1,2,3,4,5,'6']
a,b,c,d,e,f=l1
print(a,b,c,d,e)

#*号收集
a,*b,c=l1
print(a,b,c)

#*号展开,针对序列
l1=[1,2,3,4]
s1='weijichen.com'
[*l1,*s1]

#*号展开,针对字典
d1={'name':'machine learning 5th','add':'BJ,SH,*'}
[*d1],{**d1,'date':'2018-7-30'}

#,号放在最后的解包
l1=[[3,4,5]]
a=l1
b,=l1
print(a,b)

扩展阅读：运算符的优先级

第一名 - 函数调用、寻址、下标
第二名 - 幂运算 **
第三名 - 翻转运算符 ~
第四名 - 正负号
第五名 - *、/、%
第六名 - +、-

名字，赋值与名字空间

名字空间与局部作用域L,全局作用域G
在《程序设计语言——实践之路》里的术语，将名字和与其绑定的对象之间的关系，称为约束。赋值语句就是约束建立的地方。
约束既然是（name，obj）这样的关联关系，约束关系的容身之地便是就是名字空间（字典对象）

#当不在任何一个函数体内的时候的时候,locals()和globals()是同一个对象
locals() is globals()

# #而每当进入一个函数时，也会新产生一个locals(),这个locals()和globals（）就不在相同了

# #普通命名法
teacher_name='david'

#直接命名法
globals()['teacher']='david'
teacher

%whos

Python内置电池简介

BIFs 自带电池(__builtins__模块)与模块作用域B

内置模块__builtins__由解释器负责导入,受到解释器特殊对待

dir(__builtins__)

常用功能说明

help(obj) 在线帮助, obj可是任何类型    

eval(str) 表示合法的python表达式，返回这个表达式 
exec(str) 执行合法的python声明，返回字节码

#名字空间相关
dir(obj) 查看obj的name space中可见的name
vars(obj) 返回一个object的name space。用dictionary表示    
locals() 返回一个局部name space,用dictionary表示    
globals() 返回一个全局name space,用dictionary表示

#类型
type(obj) 查看一个obj的类型    
isinstance(obj,cls) 查看obj是不是cls的instance    
issubclass(subcls,supcls) 查看subcls是不是supcls的子类  

#类型转换
chr(i) 把一个ASCII数值,变成字符    
ord(i) 把一个字符或者unicode字符,变成ASCII数值    
oct(x) 把整数x变成八进制表示的字符串    
hex(x) 把整数x变成十六进制表示的字符串    
str(obj) 得到obj的字符串描述    
list(seq) 把一个sequence转换成一个list    
tuple(seq) 把一个sequence转换成一个tuple    
dict(),dict(list) 转换成一个dictionary    
int(x) 转换成一个integer    
long(x) 转换成一个long interger    
float(x) 转换成一个浮点数    
complex(x) 转换成复数

除了全局作用域Global外,还有一个作用域叫Builtin,指的就是这个模块。。

#把名为name，约束对象为'David'的kv，存储在了__builtins__这个模块中。而不是globals()中
__builtins__.name1='David'

%whos
name1

Python中的对象：不可变对象(数字与字符串)，可变对象(List,Tuple,Dict等)相应操作与访问

Python中的对象：

%config ZMQInteractiveShell.ast_node_interactivity='all'

type('weijichen.com')
type(len)

True & False 与None对象

#If后面的判断，除了bool型的true或false，还可以是对对象的判断。
#如果对象的类型是NoneObject，则和False同理，否则为True.

Test=None
if Test:
    print('None Object equals to True')
Test='t'
if Test:
    print('Other Object equals to True')

输出结果为：

Other Object equals to True

使用type查看

type('str')

type(len)

def a():
    pass

type(a)

不可变对象(数字与字符串)相应操作

#数值整形
a=100;b=200

#进制转换
a=0b0101001#bin()
b=0o4#oct()
c=0x28#hex()

#浮点型
a=3.1415

#科学计算法
c=5e13
print(c)

#数字的正负无穷
#float('inf')正无穷
#float('-inf')负无穷
if 99999999999999999<float('inf'):
    print('you win!')

#复数
a=4.3+22j
type(a)


#数值类型转换
a=4.48
b=8
int(a)

round(a,1)

延伸阅读：数值塔（numerical tower）

Python 的数值层次结构的灵感来自于 Scheme 语言的数值塔。
numbers 模块内并包括 Number, Complex,Real,Rational,Integral

##字符串型
#初始化及转义
str1='''AI'''
str2='weijichen.com'


#访问,索引及切片访问
str2[-1]

#str2[start:end:stried]
#切片访问的特点：左闭右开[)
str2[0:4]

#格式化访问1
companyName='weijichen'
str3='http://{}.cn'
print(str3.format(companyName))

#格式化访问2
print("Company name is %s" %companyName)

#格式化访问3
_='Python 3.6'#fstring only can be used under version 3.6
str4=f"fstring is new feature of {_}"
str4

        
        
#查找与替换
str3.find('o')
str3.replace('.com','.net')

#统计 count() 方法用于统计字符串里某个字符出现的次数
str3.count('com')

延伸阅读：Python3下的bytes与str

使用bytes类型，实质上是告诉Python，不需要它帮你自动地完成编码和解码的工作，而是用户自己手动进行，并指定编码格式。Python已经严格区分了bytes和str两种数据类型，你不能在需要bytes类型参数的时候使用str参数，反之亦然。

编码过程：str->encode->bytes->decode->str

ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数

b='中'
b.encode(),ord(b),hex(ord(b)),chr(20013)

输出结果为：

(b’\xe4\xb8\xad’, 20013, ‘0x4e2d’, ‘中’)

#1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。
len(b),len(b.encode())

延伸阅读：Python3下的编码

a='水a'
#对字符  水a  进行不同类型的编码为bytes对象后打印 
a_gb2312=bytes(a,encoding='gb2312')
a_gbk=bytes(a,encoding='gb2312')
a_big5=bytes(a,encoding='big5')
a_default_unicode=a.encode()#Python3是默认的unicode，就是utf-8
print('gb2312:',a_gb2312,'gbk:',a_gbk,'big5:',a_big5,'utf-8/unicode:',a_default_unicode)

#对bytes对象，指定格式进行解码后
print(a_gb2312.decode(encoding='gb2312'),a_gbk.decode(encoding='gbk'),a_big5.decode(encoding='big5'))

#gbk编码，使用big5解码，于是就乱码了
a_gbk.decode('big5')#'阨a'

#这个检测编码格式不太靠谱,仅供参考，具体还要依靠来源文档编码
import chardet
print(chardet.detect(a_gbk))

延伸阅读：Python 2.x Unicode老大难问题以及Python3中的utf-8编码[Python 2.x存储字符的中间过程]

https://blog.youkuaiyun.com/ggggiqnypgjg/article/details/72783356

Python2中的unicode是内存编码集，也就是说字符串在Python内部的表示是unicode编码（Python 2.X）,在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。

u’string’ 表示 已经是 unicode 编码的 ‘string’ 字符串

而 unicode(‘string’) 是 即将要把 ‘string’ 转化为 unicode 编码（但在执行这条语句之前，还不一定是unicode编码）

字符前面加u就表明这是一个unicode对象，这个字会以unicode格式存在于内存中

而Python3中取消了unicode，默认均为utf-8

延伸阅读：小整数缓存区与字符驻留

# Python中，根据实例是否可修改，分为可变与不可变两种类型数据 
#小整数
#Python为小整数（-5至256）已创建地址并存入在小整数缓存区
#因而超过此范围则会放入整数链表，也就是相关整数是不同的对象
#虽然是整数对象，但地址也不相同。
a=77;b=77
a is b#True   #小整数缓存池，只有同一个位置。目的是把常用的东西放在缓存池，减小开销
a=998;b=998
a is b#False

#字符串驻留intern
str_a='weijichen'
str_b='weijichen'
str_a is str_b#True 正常字符串，地址相同


str_c='Python 3.5'
str_d='Python 3.5'
str_c is str_d#False 有些稍特殊的字符串，Python认为复用性不大，于是被分配到堆上，不会在内存池中检查。因此这是两个对象。

import sys
str_e=sys.intern('Python 3.5')#强制将字符串缓存进了内存池，因此相等。str_e,str_f均指向Arena相同位置
str_f=sys.intern('Python 3.5')
str_e is str_f #True

可变对象(List,Tuple,Dict等)相应操作与访问

#Array[]:相同类型元素的序列
from array import array
a1=array('h',[1,2,3])
memv=memoryview(a1)#内存视图
len(memv)
memv[0]=55
a1
dir(a1)#array相关操作

#复制操作：对bytearray对象片断是复制，而非直接引用。
str1=bytearray('中国','utf-8')
print('str1',str1[0:3])#序列访问
tempstr=str1[0:3]#片断赋值给新变量
tempstr[0:3]=b'\xff\xff\xff'
print('tempstr:',tempstr)
print('old str1',str1)#原str1没有变化，因此是发生了复制。。

#直接操作
#bytes,bytearray,array.arrray支持视图操作
v=memoryview(str1)#对str1进行内存视图
v[0:3]=b'\xff\xff\xff'#此时对视图对象操作，即是对原str1操作了
print(str1)

a1 = array('l')#创建数组
a1.append(9)# 添加元素
a1.append(9)
a1.append(8)


#列表[]:任意元素类型对象的序列
l1=[1,'china',['AI','weijichen.com']]
l1.append('hello world')


#元组()tuple,只读列表
t1=(1,2,3,4)
dir(t1)
#只读列表是真的只读吗？
t2=(1,2,3,[4,5,6])
# t2[0]=11#报错
t2[3].append(7)#正确
t2

#tuple的单元素写法
(3)与(3,)哪个是tuple对象呢?
type((3)),type((3,))
#这里跟逗号又扯上关系，
#不仅如此，在交互式命令行中，当我们输入4,时返回的也是一个tuple对象


#集合{}set：无序的不重复元素,集合中的对象，通常叫key
s1={1,1,1,2,3,4,5,2,4,234}
l2=[1,1,1,2,3,4,5,2,4,234]
set(s1)

##frozenset
frozenset(range(7))
frozenset({x+1 for x in range(-1,7) if x%2==0})


#字典{}dict：KV对应型数据类型{
d1={'name':'david','gender':'male'}


#字典的视图
#Python3下字典视图，既同步读取字典，又却无法修改。
d1=dict(a=1,b=2)
ks=d1.keys()#返回的是主键视图,其类型为<class 'dict_keys'>
print('b' in ks)#直接从该视图中观察字典
for key in ks:
    print(key,d1[key])
    

d1['b']=3#更新原字典
d1['c']=99#对原字典插入新值
for key in ks:#此时并未再次运行d1.keys()，也能看到原字典的变化
print(key,d1[key])    


#标准库下的其它字典OrderedDict
from collections import OrderedDict

od1=OrderedDict()#按主键首次插入顺序进行排序

od1['a']=7
od1['z']=8
od1['b']=9
od1

延伸阅读 Python中的三种赋值方式 =,copy,deepcopy

import copy
a=[1,2,3,[4,5,6]]
b=a#赋值
c=copy.copy(a)#shallow copy
d=copy.deepcopy(a)#Deep copy

#列表推导式：从一个列表中生成一个新的列表，简化了循环的写法
l1= [x for x in range(30) if x%3==0]
l1

练习：

接收一个字符串，判断其做为Python标识符是否合法

a.isidentifier()

以单词为单位反转字符串

将’I am a student’按单词为单位进行进行反转字符串，得到’I ma a tneduts’

[item[::-1] for item in 'I am a student'.split(' ')]

词频统计wordcount

请计算['AI','weijichen.cn','Python','AI','Julyedu','Python']这个列表中每个单词出现的次数

for item in ll:
    ll.count(item)

输入一个字符串返回满足以下条件的字符串

• 如果字符串长度小于3，打印出原字符串
• 否则：
  • 如果字符串是以 ‘ing’ 结尾的，就在末尾添加 'ly’后打印
  • 添加 ‘ing’ 到字符串的末尾后打印

例如： 输入 a 返回 b 输入 ab 返回 ab 输入 bing 返回 bingly 输入 chang 返回 changing

ss=input()
if len(ss) < 3:
    print(ss)
elif ss.endswith("ing"):
    print("%sly"%ss)
else:
    print("%sing"%ss)

集合操作

• 生成一个包含从0到100数字的列表，对其随机采样两次。分别输出两次采样的交集和并集
• 参考使用random模块下sample方法

import random
arr=[]
for i in range(10):
    arr.append(random.randint(0,100))
arr
one=random.sample(arr,1)
sec=random.sample(arr,1)

set(one) & set(sec)
set(one) | set(sec)