python基础知识02

基础知识
标识符
字母、数字、下划线组成且首字母不可以是数字

包 类 函数 变量 常量

代码规范：常量名全部大写、变量名全部小写、函数名小写、类遵守驼峰法

python 严格区分大小写

以单下划线开头的标识符 禁止外部访问，不能通过from XXX import XXX导入 例如_foo

以双下划线开头的标识符 为类的私有成员 例如 __foo

以双下划线开头和结尾的标识符 特殊方法专用的标识 例如 init()

python保留字 用作语法功能的专用标识符，不可以用作自定义标识符

注释

单行注释

“”" “”" 注释文档 可通过 XXX.doc 来查看文档内容，且注释文档紧跟在类或函数后面，不可放在任意位置

python 通过换行 和缩进来 表示代码块 同一代码块所及空格相同，若不一致报错“IndentationError”

原生字符串 r"this is a line \n"

算术运算符 + - * / % ** //
比较关系运算符 > = < >= <= == != <>
赋值运算符 = += -= *= /= %= **= //=
逻辑运算符 and or not
位运算符 二进制运算 & | ^ ~
成员运算符 in not in
身份运算符 is is not 比较的是对象
三目运算符 (a>b)?a:b 为真时的结果 if 判定条件 else 为假时的结果

运算符优先级
同级别从左往右
**
*/%//

<<
&
^|
< > <= >=
<> == !=
= %= /= //= -= += *= **=
is is not
in not in
not or and

a = [1,2,3,4,5]
b = a
print("a变量的内存地址：",id(a))
print("b变量的内存地址：",id(b))
if a is b:
    print("共同指向同一个对象（地址）")
b = a[:]   #赋值运算符，重新定义b并给b赋值
print("b",b)
print("a",a)
if a is b:   #身份运算符
    print("共同指向同一个对象（地址）")
elif a is not b:
    print("共同指向不同对象（地址）")
    if b == a:   #关系运算符
        print("a和b的值一样")
if a is b and a==b :
    print("a和b指向同一个对象且值是一样的")
elif a is not b and a == b:
    print("a和b是不同的对象，但对象的值是一样的，就像同一个商店买了两个相同的杯子，一个放在自己家，一个放在姥姥家")
print("a变量的内存地址：",id(a))
print("b变量的内存地址：",id(b))

a变量的内存地址： 1955519449416
b变量的内存地址： 1955519449416
共同指向同一个对象（地址）
b [1, 2, 3, 4, 5]
a [1, 2, 3, 4, 5]
共同指向不同对象（地址）
a和b的值一样
a和b是不同的对象，但对象的值是一样的，就像同一个商店买了两个相同的杯子，一个放在自己家，一个放在姥姥家
a变量的内存地址： 1955519449416
b变量的内存地址： 1955519368008

输入输出
input() 获取用户输入 保存成字符串
print() 输出字符串，在屏幕上显示
print(,)每个逗号代表一个空格
print(“%d,%s”%(10,“string”)) 输出格式化语法

数据类型
int 32位 4个字节 只有长整型
float 1.23 1.23e9 12.3e8
数据类型转化 int(3.9) 截去小数部分仅保留整数部分
math库

abs(x) 取绝对值 返回整数
ceil(x) 返回数字的上个整数 math.ceil(4.1) 返回5
exp(x) 返回e的X次幂
fabs(x) 取绝对值 返回浮点数
floor(x) 返回下舍整数 math.floor(4.9) 返回4
log(x) math.log(100,10) 返回2
log10(x) math.log10(100) 返回 2.0
max(x1,x2,…) 返回最大值
min(x1,x2,…) 返回最小值
modf(x) 返回x的整数部分与小数部分，
m = math.modf(4.5)
print (m) (0.5, 4.0)
pow(x,y) x**y
round(x[,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
b = math.log(22,2)
b = round(b,2)
print (b) 4.46

sqrt(x) 返回x的平方根

布尔类型：True False
布尔类型可以进行 and or not 运算
空值：None 属于NoneType类型

列表

列表是有序可重复的元素集合，可嵌套、迭代、修改、分片、追加、删除、成员判断
创建列表,可多层嵌套列表，元素个数无限制
lis = [] #创建空列表
lis = [1,2,3]
lis = [1,‘a’,[11,22],{‘k1’:‘v1’}]
访问列表内的元素
列表索引从0开始到len(lis)-1结束，访问列表可以通过lis[n] n 为列表的索引位置，最后一个是len(lis)-1

修改列表的值：直接对元素进行重新赋值
lis[0]=1

删除元素
del lis[0] #根据索引位置删除
lis.remove(“b”) #删列表内的指定数
lis.pop() #删列表的最后一位

列表的特殊操作
[1,2,3]+[4,5,6] [1,2,3,4,5,6]
[‘Hi!’]*4 [‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’]
3 in [1,2,3] True
for x in [1,2,3]:
print x

针对列表的常用函数
len(list) 获取列表长度
max(list) 返回列表元素最大值
min(list) 返回列表元素最小值
list(seq) 将序列转换为列表

切片
list[start:end]

start 代表起点索引
end 代表结束点索引
[] 区间是左闭右开
list[1:4] 会截取列表的索引为1/2/3的3个元素，不会截取索引为4的元素

复制列表
newlist = lis[:]
列表反转 lis = lis[::-1]

a = [1,2,3,4,5,6,7,8,9]
print (a[::2]) [1, 3, 5, 7, 9]
print (a[1::2]) [2, 4, 6, 8]
print (a[::-1]) [9, 8, 7, 6, 5, 4, 3, 2, 1]
print (a[-1::-1]) [9, 8, 7, 6, 5, 4, 3, 2, 1]
print (a[8:3:-2]) [9, 7, 5]
print (a[::]) [1, 2, 3, 4, 5, 6, 7, 8, 9]
print (a[-4:]) [6, 7, 8, 9]

[beg🔚step]
当step小于0时 beg默认为-1 且为逆序步长
a[0:8:-1] 无数据返回

列表的内置方法
append(obj) 在列表末尾添加新的对象
count(obj) 计算数据出现的次数
extend(seq) 将一个新序列拓展到原来的列表，一次在原列表追加多个值
index(obj) 某个值首次出现的位置
insert(index,obj) 在列表index位置插入数值obj
pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

remove(obj) 删除列表中第一个匹配obj
reverse() 反向列表中的元素
sort() 对原列表进行排序
copy() 复制列表
clear() 相当于 del lis[:]

a = [1,2,3,4,1,6,7,8,9]
print (a[::2]) #[1, 3, 1, 7, 9]
print (a[1::2]) #[2, 4, 6, 8]
print (a[::-1]) #[9, 8, 7, 6, 1, 4, 3, 2, 1]
print (a[-1::-1]) #[9, 8, 7, 6, 1, 4, 3, 2, 1]
print (a[8:3:-2]) #[9, 7, 1]
print (a[::]) #[1, 2, 3, 4, 1, 6, 7, 8, 9]
print (a[-4:]) #[6, 7, 8, 9]

a.append(10)
print (a[:]) #[1, 2, 3, 4, 1, 6, 7, 8, 9, 10]
print (a.count(1)) #2

#seq = [‘i’,‘am’,‘a’,‘student’,‘grade’,‘2’,‘class’,‘6’,‘12’]
#seq = (‘i’,‘am’,‘a’,‘student’,‘grade’,‘2’,‘class’,‘6’,‘2’)
#a.extend(seq)
#print (a[:])

#print (a.index(‘a’))
#print (a.index(‘2’))

#a.insert(0,‘fist’)
#print (a[:])

a.pop()
print (a[:]) #[1, 2, 3, 4, 1, 6, 7, 8, 9]

p=a.pop(a[1]) #删除的的是a[2] 的数据
print § #3
print (a[:]) #[1, 2, 4, 1, 6, 7, 8, 9]
op = a.pop(0)
print (op) #1
print (a[:]) #[2, 4, 1, 6, 7, 8, 9]

#a.remove(‘am’)
#print (a[:])
a.reverse()
print (a[:]) #[9, 8, 7, 6, 1, 4, 2, 1]
a.sort()
print (a[:]) #[1, 1, 2, 4, 6, 7, 8, 9]
b = a[:]
print (b[:]) #[1, 1, 2, 4, 6, 7, 8, 9]
c = a.copy()
print (c[:]) #[1, 1, 2, 4, 6, 7, 8, 9]
a.clear()
print(a[:]) #[]
a = [‘i’,‘am’,‘a’,‘student’,‘grade’,‘2’,‘class’,‘6’,‘12’]
print (a[:]) #[‘i’, ‘am’, ‘a’, ‘student’, ‘grade’, ‘2’, ‘class’, ‘6’, ‘12’]
del a[:]
print (a[:]) #[]

元组
元组是一种不可变的序列结构，即内容不可变的列表
元组是用圆括号来表示

元组和列表的相同点
1、使用方括号加下标的方式访问元素
2、切片（形成新元组对象）
3、count()/index()
4、len()/max()/min()/tuple()

元组没有的功能
1、修改、新增元素
2、删除某个元素（但可以删除整个元组）
3、所有会对元组内部元素发生修改动作的方放。例如 remove append pop 等方法

元组支持的特殊操作
len((1,2,3)) 3
(1,2,3)+(4,5,6) (1,2,3,4,5,6)
(‘Hi!’)*4 (‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’)
3 in [1,2,3] True
for x in (1,2,3):
print x

字符串 (python 无单字符概念 ‘c’ 这个也是当作字符串处理)
字符串是不可变的序列数据类型
split rsplit lsplit

a = “jshshkjsjsjhshsjsjsjssjsjhhkfgmssdnkdpoqm”
d = “122433446”
s = " "
str1 = " ********"
uw = ‘WEH JJSJ JSJSJ LDKJD OCJIEQU Uas jjhjj’
print (a) jshshkjsjsjhshsjsjsjssjsjhhkfgmssdnkdpoqm
b = a.capitalize()
print (b) Jshshkjsjsjhshsjsjsjssjsjhhkfgmssdnkdpoqm
c = str1.center(20)
print© ********
co=a.count(‘h’,0,len(a))
print (co) 6

by = a.encode()
print (by) b’jshshkjsjsjhshsjsjsjssjsjhhkfgmssdnkdpoqm’
print (type(by)) <class ‘bytes’>

print(a.endswith(‘oq’)) False

print (a.find(‘s’,30,len(a))) 31
print(a.find(‘i’)) -1

print(“your {} is {} your age is {}”.format(‘name’,‘xiaomei’,‘18’)) your name is xiaomei your age is 18
#print (a.index(‘i’)) #报错 和 find 功能类似 只不过index找不到字符时会报错

print (“纯字符”,a.isalnum()) #纯字符或数字 纯字符 True

print (“字符均字母”,a.isalpha()) 字符均字母 True

print (“只有十进制数字”,d.isdecimal()) 只有十进制数字 True

print (“包含数字”,d.isdigit()) 包含数字 True
print (‘小写字符’,a.islower()) 小写字符 True
print (‘只有数字’,d.isnumeric()) 只有数字 True
print (‘只有空格’,s.isspace()) 只有空格 True
print (‘大写字符’,a.isupper()) 大写字符 False
print (str1.join(a))
j ********s ********h ********s ********h ********k ********j ********s ********j ********s ********j ********h ********s ********h ********s ********j ********s ********j ********s ********j ********s ********s ********j ********s ********j ********h ********h ********k ********f ********g ********m ********s ********s ********d ********n ********k ********d ********p ********o ********q ********m

print(str1.ljust(20)) ********

print (uw.lower()) weh jjsj jsjsj ldkjd ocjiequ uas jjhjj

print (str1.lstrip()) #********

print (uw.partition(‘JSJS’)) #分成3个元素的元组 ('WEH JJSJ ', ‘JSJS’, ‘J LDKJD OCJIEQU Uas jjhjj’)
print (uw.replace(‘JSJS’,‘world’)) WEH JJSJ worldJ LDKJD OCJIEQU Uas jjhjj

print (uw.rfind(‘D’)) 19
print (uw.rindex(‘D’)) 19

print (uw.rjust(60)) WEH JJSJ JSJSJ LDKJD OCJIEQU Uas jjhjj
print (uw.rfind(‘JSJS’)) 9
print (uw) WEH JJSJ JSJSJ LDKJD OCJIEQU Uas jjhjj
print (uw.split(‘JS’)) [‘WEH J’, 'J ', ‘’, ‘J LDKJD OCJIEQU Uas jjhjj’]
print (a.upper()) JSHSHKJSJSJHSHSJSJSJSSJSJHHKFGMSSDNKDPOQM
print (a.zfill(60)) 0000000000000000000jshshkjsjsjhshsjsjsjssjsjhhkfgmssdnkdpoqm

字典：不定长，可变，散列的集合类型（非序列类型）
键:值 key:value
创建字典：dict()函数是Python内置的创建字典的方法
dic = {} 创建空字典
dic = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}
dict([(‘sape’, 4139), (‘guido’, 4127), (‘jack’, 4098)])
dict(sape=4139, guido=4127, jack=4098)

访问字典:字典采用把相应的键放入方括号内获取对应值的方式取值
dic = {‘Name’: ‘Jack’,‘Age’: 7, ‘Class’: ‘First’}
dic[‘Name’]

增加或修改

import json
dic = {}
print (id(dic))
dic[‘name’] = ‘xiaowang’
print (id(dic))
print (dic)

param = {“currentPage”:1,“limit”:20,“cityCode”:2500,“categoryId”:67,“sortField”:“saleIndex”,“sortType”:“desc”,“isFilter”:“false”,“isQuery”:“true”}
print(type(param),param)

param_str = json.dumps(param)
print (type(param_str),param_str)
param_dict = json.loads(param_str)
print (type(param_dict),param_dict)

print(“param[‘currentPage’]:”,param[‘currentPage’])

param[‘name’] = ‘manman’

print (param)
print (len(param))

print (param_dict)
del param_dict[‘currentPage’]
limit = param_dict.pop(‘limit’)
last = param_dict.popitem()
print (param_dict)

param_dict.clear()
print (param_dict)

param_copy = param.copy()
print(“param_copy:”,param_copy)

seq=(‘name’,‘sex’,‘age’)
new_dict = dict.fromkeys(seq,10)
print (new_dict)
value = new_dict.get(‘name’)
print (value)
keys_values = new_dict.items()
print (“dict.items”,keys_values)
keys = new_dict.keys()
print (“dict.keys”,keys)
values = new_dict.values()
print (“dict.values”,values)
name = new_dict.pop(‘name’)
print (“dict.pop name:”,name,new_dict)

param1 = {‘name’:‘manman’,‘class’:2,‘grade’:6}
print (param)
param.update(param1)
print (“param.update”,param)

for key,value in param.items():
print (key,value)

for key in param.keys():
print (key,param[key])

for value in param.values():
print (value)

for key in param:
print (key)

dic1={}
for i in ‘abcdefghijklmnopqrstuvwxyz’:
dic1[i] = ord(i)
print (i,dic1[i])

str = “hshshhshshkdjopoqiazse”
print (type(str))
by = str.encode()
print (type(by))
str1 = by.decode()
print (type(str1))

集合set

set集合是一个无序不重复元素的集

selection = set() #创建空集合
print (type(selection)) <class ‘set’>
selection.add(10) #为集合增加元素
print (selection) {10}
selection.clear() #清空集合
print(selection) set()

st1 = set([1,1,2,2,3,3,48,4,2,5,5]) #创建集合
print (st1) {1, 2, 3, 4, 5, 48}
st2 = st1.copy() #复制集合
print (st2) {48, 1, 2, 3, 4, 5}
st1.update(‘hello’) #将seq更新到st1集合中，只能更新字符串
print(“update hello”,st1) update hello {1, 2, 3, 4, 5, ‘l’, 48, ‘e’, ‘o’, ‘h’}
st1.remove(1) #删除,指定删除的数据
print(“remove 1”,st1) remove 1 {2, 3, 4, 5, ‘l’, 48, ‘e’, ‘o’, ‘h’}
st1.pop() #删除，不可指定参数
print (“pop”,st1) pop {3, 4, 5, ‘l’, 48, ‘e’, ‘o’, ‘h’}
st1.discard(‘e’) #删除，且无删除项时不报错
print(“discard”,st1) discard {3, 4, 5, ‘l’, 48, ‘o’, ‘h’}

list1 = [1,23,6,7,8]
list2 = [2,34,5,6,7,8]

diff1 =set(list1).difference(list2) #差集
print (diff1) {1, 23}

un = set(list1).union(list2) #并集
print(“union”,un) union {1, 2, 34, 23, 5, 6, 7, 8}

inter = set(list1).intersection(list2) #交集
print(“intersection”,inter) intersection {8, 6, 7}

set(list1).difference_update(list2)

print (‘difference_update’,dif_up)

print (‘list1’,list1) list1 [1, 23, 6, 7, 8]
print (‘list2’,list2) list2 [2, 34, 5, 6, 7, 8]

a = set(‘adradjoshdjdandke’)
b = set(‘lskwonxjsu’)
j = a-b
#jia = a+b #不支持
jiao = a&b
huo = a|b
yihuo = a^b
print(“a”,a) a {‘e’, ‘o’, ‘d’, ‘a’, ‘s’, ‘n’, ‘h’, ‘j’, ‘r’, ‘k’}
print(“b”,b) b {‘w’, ‘x’, ‘l’, ‘o’, ‘u’, ‘s’, ‘n’, ‘j’, ‘k’}
print(“a-b”,j) a-b {‘e’, ‘d’, ‘a’, ‘h’, ‘r’}
#print(‘a+b’,jia)
print (‘a&b’,jiao) a&b {‘o’, ‘s’, ‘n’, ‘j’, ‘k’}
print (‘a|b’,huo) a|b {‘l’, ‘d’, ‘a’, ‘j’, ‘k’, ‘w’, ‘x’, ‘e’, ‘o’, ‘u’, ‘s’, ‘n’, ‘h’, ‘r’}
print (‘a^b’,yihuo) {‘w’, ‘x’, ‘e’, ‘l’, ‘d’, ‘u’, ‘a’, ‘h’, ‘r’}