python底蕴(二卡塔尔(英语:State of Qatar)----数据类

作者:电脑系统

基本数据类型-数字

文件的操作

 

光标位置:

f=open("user_msg.txt","r")

print(f.tell())

 

将光标位置回到某个位置:

f.seek(0) //0即为开始

 

获取文件编码

f.encoding()

 

获取文件句柄编号

f.fileno()

 

判断是否是一个tty

f.isatty()

 

判断是否能将光标移动到某一位置,若能移动,返回True,不能移动返回False

f.seekable()

 

//清空文件

f.truncate()

 

//从头开始截断文件到第几个字符

f.truncate(10)

 

open方式是以读 追加的方式打开 r

 

open方式是以写读的方式打开 w 先创建一个文件,在往里面写

 

open方式是以二进制的形式读文件, “rb” 两种情况会使用:1、网络传输 2、跨平台传输

 

 

字符编码

十进制与二进制之间的转换只能解决计算机理解数字的问题,那么为文字的话需要怎么让计算机去理解呢?
于是就有了一种曲线救国的方法,既然数字可以转换成十进制,那么我们只需要想办法解决文字转换成数字的问题,那么文字不就是可以表示成二进制了吗?
可是文字应该怎么转换成二进制呢? 就是强制转换
我们自己强行约定了一个表,把文字和数字对应上,这张表就等于是进行了翻译,我们可以拿一个数字来对比对应表中的文字,反之亦然。

内置函数

 

函数代表绝对值 :abs()

ex: n = abs(-100) print(n)

 

res: n=100

 

函数内为迭代参数,所有参数为真才为真 all()

ex: s= all([1,2,3,4,5,6,0])

print(s)

 

res:s =false

 

 

 

ex: s= all([1,2,3,4,5,6,10])

print(s)

 

res:s =true

 

函数内为迭代参数,任意参数为真,则为真 any()

ex: s= any([1,2,3,4,5,6,0])

print(s)

res:s =true

 

ex: s= all([0,none,' ',1])

print(s)

res:s =true

 

自动执行对象的_repr_方法:ascii()

ex: class Foo:

def _repr_(self):

retrun "111"

n=ascii(Foo())

print()

 

十进制转换为二进制bin() 0b 二进制

 

十进制转换为八进制oct() 0o 十进制

 

十进制转换为16进制 hex() 0x 16进制

 

 

bytes() 转换字符串 按照指定的编码格式

 

n=bytes("李先生",encoding='uft-8')

print(n)

 

n=bytes("李先生",encoding='gbk')

print(n)

 

将之前的字节转换成字符串

str()

n=bytes('李先生',encoding=‘utf-8’)

print(n)

s=str(n,encoding='utf-8')

print(s)

 

 

open()

open('db','r / w / x /a')

r 读取

w 写入(写入时先情况再写)

x 如果文件存在,报错,如果不存在,则创建并写入内容

a 追加

 

若使用rb wb 等,则是程序直接返回或是存放二进制,即0101。

若open 中使用了“r b”类型的,则读取的时候是读取一个字节 若未使用,则读取的是一个字符

 

跨平台的时最好使用二进制读取,这样出现错误的情况较少。

 

seek() seek永远是以字节的方式找位置 因此若读取位置存在中文则会出现乱码的情况。

seek找到的位置,若写入数据,则会将后续的内容覆盖。

 

tell() 会将当前指针位置找出。

 

write() 写数据

 

fileno()

 

flush()强制刷新数据到硬盘

 

isatty() 判断是否同意tty设备

 

readable() 判断文件是否可读

 

seekable()判断是否可以移动指针

 

readline() 按照行来读取文件

 

writeable()文件是否可写

 

truncate()用来截断数据 使用方式是使用seek()进行定位,然后会将seek()定位之前的截断保留。

 

with open(’db1‘)as f1. open('db2') as f2:

pass

 

 

函数默认返回None

 

ex:

 

li=[11,22,33,44]

 

def f1(arg):

arg.append(55)

 

li=f1(li)

若li=f1(li)这种方式,则li被重新赋值为了None,之前赋值成功的[11,22,33,44,55]被覆盖

 

打印 print(li) 可得 None

 

若f1(li)这种方式,则li赋值成为[11,22,33,44,55]

 

打印print(li)可得[11,22,33,44,55]

 

 

 

 

获取两个列表l1=[11,22,33] l2=[22,33,44]中相同元素集合

l1=[11,22,33]

l2=[22,33,44]

l3=set(l1)

l4=set(l2)

print(l3.symmetric_difference(l4))

 

结果为{11, 44}

 

将字符串“老男人”转换成utf-8编码的字节类型

s='老男人'

n=bytes(s,encoding='utf-8')

 

print(n)

 

s=str(n,encoding='utf-8')

print(s)

 

如何计算数字的绝对值

n=-100

s=abs(n)

print(s)

 

 

 

False的情况: [] 、{}、None、0、" "、()

 

 

chr() 将ASCII码转换为其对应的字母

ord()将字母转换为其对应的ASCII码

 

 

import random

 

s=[]

for i in range(6):

temp=random.randrange(65,91)

s1=chr(temp)

s.append(s1)

res=''.join(s)

print(res)

 

 

dir()表示列举 一个函数能够提供的功能

print(dir(dict))列举字典函数能够提供的功能

 

 

divmod()

divmod(a,b)方法返回的是a//b(除法取整)以及a对b的余数

返回结果类型为tuple

 

isinstance()判断实例是否为对应类的实例

 

 

filter()

 

li=[11,22,33,44,55,66]

ret=filter(f2,li)

print(list(ret))

filter参数,循环第二个参数,让每个循环元素执行f2 如果函数返回值为True,表明元素合法

 

 

map()函数,可迭代的对象(可以for循环的东西)

li=[11,22,33,44,55]

def f2(a)

return a 100

result=map(f2,li) 亦或者result=map(lambda a:a 100,li) lambda表达式表达意思相似。

print(list(result))

结果即为li列表里面的每个值都增加了100

 

filter与map函数的区别

filter 函数返回True,将元素添加到结果中。

map 将函数返回值添加到结果中。

 

 

globals()函数代表全局变量

locals()函数代表局部变量

 

hash()计算哈希值

hex()将一个十10制转换为16进制。

 

pow()

 

repr()直接执行对应参数类型的repr参数

 

reversed()反转

 

round() 如round(3.2213,2)即返回3.2213仅带两位小数的数字,结果为3.22,第三位小数执行四舍五入

 

sorted()效果等同于.sort()

 

l1=["alex",11,22,33,44]

l2=["is",11,22,33,44]

l3=["sb",11,22,33,44]

 

zip()

 

美高梅手机登录网站 1

转换成的基本数据类型是list

 

 

关于小数不精准问题

python默认是17位精准度,也就是小数点的后16位,尽管有16位,但这个精确度还是越往后越不准的。

首先,这个问题不是只存在在python中,其他语言也有同样的问题

其次,小数不精准是因为在转换成二进制的过程中会出现无限循环的情况,在约省的时候就会出现偏差。

比如:11.2的小数部分0.2转换为2进制则是无限循环的00110011001100110011...

单精度在存储的时候用23bit来存放这个尾数部分(前面9比特存储指数和符号);同样0.6也是无限循环的;

这里有一个问题,就是当我们的计算需要更高的精度(超过16位数)的情况下怎么做呢?

#这里需要借助decimal模块的getcontext()和Decimal()方法
>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 50      #将小数点后的尾数修改到50
>>> a = Decimal(1)/Decimal(3)   #在分数计算中结果正确,如果直接定义超长精度小数不会准确
>>> a
Decimal('0.33333333333333333333333333333333333333333333333333')
>>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> Decimal(a)
Decimal('3.141592653513650912344701282563619315624237060546875')

列表的使用

 

追加

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
names=name[1:4]
print(names)

 

//取下标为1到4的数,包括1,但不包括4

结果为 ['lisi', 'wangwu', 'zhaoliu']

 

names=name[1:-1]
print(names)

 

//取下标为1到-1的数,包括1,但不包括-1 -1位最后一位,从后面倒数即为-1

结果为['zhangsan', 'lisi', 'wangwu', 'zhaoliu']

 

names=name[0:3]
print(names)

 

//如果从头开始的话,0可以省略掉,即为[:3]

结果为['zhangsan', 'lisi', 'wangwu']

 

 

names=name[0:]

//如果想取最后一个的值,就不能写-1

 

 

names=name[0::2]

//如果想要改变name的取值步长,需要如上这么写,第一个0为开始取值的位数,第一个冒号后面跟着要取到哪个的值,此处为取到最后一个,因此可以不写,第二个冒号后面跟着取值的步长,此处为2即取值的时候是取1,3,5,7,9,隔一个取一个值。

最终可以简化为 names=name[::2]

 

 

 

追加

 

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
name.append('wangermazi')
print(name)

res:

['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan','wangermazi']

//直接在最后一位上追加数值

 

插入

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
name.insert(2,"123")
print(name)

res:

name=['zhangsan','lisi','123','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']

//将“123”插入到下标为[2]的位置上。

 

 

修改

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
print(name)
name[2]='thisisnew'
print(name)

直接将下标为[2]的数值更改为新的

res:

['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']

['zhangsan', 'lisi', 'thisisnew', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']

 

 

删除

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
del name
print(name)

//直接将此列表删除

res:

NameError: name 'name' is not defined

直接报错

 

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
name.remove('zhangsan')
print(name)
name.remove('laojiu')
print(name)

//删除指定元素

结果为

第一个print ['lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']

第二个print ['lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'shiquan']

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
name.pop()
print(name)

//删除最后一个数值

结果为['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu']

 

 

扩展

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
b=['1','2','3','4']
name.extend(b)
print(name)

//直接将列表b插入到列表name中最后面

结果为['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan', '1', '2', '3', '4']

 

拷贝

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
names=name.copy()
print(names)

复制 copy copy是直接将原来的数据复制一份,此时更改不会影响到原有的

copy的话仅仅复制第一层,而不会copy第二层,是因为第二层数据量有可能非常大

 

套用列表:套用的小列表仅会引用其存储地址,不会全部将此复制 数据是共享的

namess=['zhangsan',['1','2','3','4'],'lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
namesss=namess.copy()
namess[1][0]='8123'
namess[2]='sasss'
print(namess)
print(namesss)

结果为:

['zhangsan', ['8123', '2', '3', '4'], 'sasss', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']

['zhangsan', ['8123', '2', '3', '4'], 'lisi', 'wangwu', 'zhaoliu', 'tianqi', 'laiba', 'laojiu', 'shiquan']

 

若要真正全部复制一份,则需要使用一个库

引入copy : import copy

 

copy.copy 跟 *.copy一样

 

copy.deepcopy 深度拷贝,则将数据完全复制,两个数据完全独立。

 

 

id(name)查看name的内存地址

 

 

统计

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
s=name.count('list')
print(s)

 

 

排序&反转

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
name.sort() //排序
print(name)

 

 

3.0里面不同数据类型不能放在一起排序,最经典的是数字和字母无法在一起排序。

 

name,reverse() //反转

 

获取下标

 

name=['zhangsan','lisi','wangwu','zhaoliu','tianqi','laiba','laojiu','shiquan']
s=name.index('lisi')
print(s) //若不进行循环获取,只会返回找到的第一个下标

 

列表的合/并/交集的使用 

list_1=[1,2,3,4,5,6]

list_2=[5,6,7,8,9,10]

 

取两个集合的交集:

list_1.intersection(list_2)

or

list_1 & list_2

 

取两个集合的并集:

list_1.union(list_2)

or

list_1 | lsit_2

 

取两个集合中前一个集合有,第二个集合没有的:

list_1.difference(list_2)

or

list_1-list_2

 

判断集合1 是否是集合2的子集

list.issubset(list_2)

 

取两个集合都没有的部分,对称差集

list_1.symmertic_difference(list_2)

or

list_1 ^ list_2

 

判断两个集合是否存在交集

list_1.isdisjoint(list_2)

 

 

列表增删改查

 

增加:

单项 list.add()

多项: list.update([888,999,111])

 

删除:list.remove()

 

查找: if "**" in list_1

列表的常见操作

这里用了不同的列表,请注意查看!

append() 追加一个元素在列表的最后

list = ['xiaoyafei'] list.append('lipeng') list ['xiaoyafei', 'lipeng']

切片

#切下表为2到下标为4的元素,顾头不顾尾
>>> list
['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']
>>> list[2:5]
['zhangsan', 'lisi', 'wanger']

#切下表为2到最后的元素,顾头也顾尾
>>> list
['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']
>>> list[2:]
['zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']

#切从第一个到最后一个
>>> list
['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']
>>> list[:]
['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']

#切最后两个,顾头也顾尾
>>> list
['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']
>>> list[-2:]
['zhaoliu', 'likun']

# 步长语句,只切下表为奇数
>>> list
['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']
>>> list[::2]
['xiaoyafei', 'zhangsan', 'wanger', 'zhaoliu']

count() 查看存在多少相同的元素

list1 [2, 2, 3, 4, 1, 2] list1.count(2) 3 list2 = ['lipeng','likun','lipeng','weiwenwu','lihang','lisiru','lipeng'] list2.count('lipeng') 3

index() 获取元素的下标

list ['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun'] list. #tab键 list.add( list.dir( list.getattribute( list.imul( list.lt( list.reduce_ex( list.setitem( list.clear( list.insert(
list.class( list.doc list.getitem( list.init( list.mul( list.repr( list.sizeof( list.copy( list.pop(
list.contains( list.eq( list.gt( list.iter( list.ne( list.reversed( list.str( list.count( list.remove(
list.delattr( list.format( list.hash list.le( list.new( list.rmul( list.subclasshook( list.extend( list.reverse(
list.delitem( list.ge( list.iadd( list.len( list.reduce( list.setattr( list.append( list.index( list.sort(
list.index('lipeng') 1

获取指定下标的值

list ['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun'] list[2] 'zhangsan'

insert() 插入一个元素

list ['xiaoyafei', 'lipeng', 'zhangsan', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']

# 在下表为3的元素前插入一个元素

list.insert(3,'xixihaha') list ['xiaoyafei', 'lipeng', 'zhangsan', 'xixihaha', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']

列表的修改

list2 ['lipeng', 'likun', 'lipeng', 'weiwenwu', 'lihang', 'lisiru', 'lipeng'] list2[2] = 'xixihaha' list2 ['lipeng', 'likun', 'xixihaha', 'weiwenwu', 'lihang', 'lisiru', 'lipeng']

# 想要连续修改或者批量修改,可以使用切片,因为会把字符串拆掉,不够的话会自动创建
>>> list
['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi', 'wanger', 'mazi', 'zhaoliu', 'likun']
>>> list[5:] = 'xixihaha'
>>> list
['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi', 'x', 'i', 'x', 'i', 'h', 'a', 'h', 'a']

pop() 删除列表的最后一个元素

list2 ['lipeng', 'likun', 'xixihaha', 'weiwenwu', 'lihang', 'lisiru'] list2.pop() 'lisiru' #会把删除的东西打印出来 list2 ['lipeng', 'likun', 'xixihaha', 'weiwenwu', 'lihang']

remove() 删除指定元素

list2 ['lipeng', 'likun', 'xixihaha', 'weiwenwu', 'lihang'] list2.remove('likun') #删除元素不会打印 list2 ['lipeng', 'xixihaha', 'weiwenwu', 'lihang']

# 也可以使用del
>>> list2
['lipeng', 'xixihaha', 'weiwenwu', 'lihang']
>>> del list2[1]
>>> list2
['lipeng', 'weiwenwu', 'lihang']

# 批量删除
>>> list
['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi', 'x', 'i', 'x', 'i', 'h', 'a', 'h', 'a']
>>> del list[5:]
>>> list
['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi']

    pop()和remove()和del的区别:
        在于pop()函数删完元素之后,会将删除的元素打印出来,而remove()函数以及del不会打印

列表的循环

list ['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi'] for i in list: ... print(i) ... xiaoyafei lipeng xixihaha xixihaha lisi

    for和while的区别:
        while是可以支持死循环的,例如while True,而for循环是有边界的

sort() 根据ASCII码标表顺序排序

# 有重复的元素,但是在排序时就去重了
>>> list3 = ['a','b','c','d','e','A','D','c','f','g']
>>> list3.sort()        不会立马就打印出来
>>> list3
['A', 'D', 'a', 'b', 'c', 'c', 'd', 'e', 'f', 'g']

reverse() 把整个列表倒过来

list3 ['A', 'D', 'a', 'b', 'c', 'c', 'd', 'e', 'f', 'g'] list3.reverse() list3 ['g', 'f', 'e', 'd', 'c', 'c', 'b', 'a', 'D', 'A']

把两个列表进行相加

list ['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi'] list3 ['g', 'f', 'e', 'd', 'c', 'c', 'b', 'a', 'D', 'A'] list list3 ['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi', 'g', 'f', 'e', 'd', 'c', 'c', 'b', 'a', 'D', 'A']

# 或者也可以使用extend()函数
>>> list
['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi']
>>> list3
['g', 'f', 'e', 'd', 'c', 'c', 'b', 'a', 'D', 'A']
>>> list.extend(list3)      #同样不会立马打印出来
>>> list
['xiaoyafei', 'lipeng', 'xixihaha', 'xixihaha', 'lisi', 'g', 'f', 'e', 'd', 'c', 'c', 'b', 'a', 'D', 'A']

clear() 清空列表

list3 ['g', 'f', 'e', 'd', 'c', 'c', 'b', 'a', 'D', 'A'] list3.clear() list3 []

流程控制

 计算机程序在解决某个具体问题时,包括三种情形,即顺序执行所有的语句、选择执行部分的语句和循环执行部分语句,这正好对应着程序设计中的三种程序执行结构流程:顺序结构、选择结构和循环结构。

 

顺序结构

 

只要按照解决问题的顺序写出相应的语句就行,它的执行顺序是自上而下,依次执行。

 

选择结构:

 

选择结构用于判断给定的条件,根据判断的结果判断某些条件,根据判断的结果来控制程序的流程。

形式为

if<条件>:

  if<条件>:
    <语句1>
  elif<条件>:
    <语句2>:
else:
  <语句3>

 

循环结构

包含for循环和while循环

for循环的形式为

for <循环变量> in <循环对象>:

  <语句1>

 

可限定循环次数

for i in rang(0.len(循环对象))

 <语句1>

 

for语句使用range()函数可以构建基于已知循环次数的循环程序,也可以以range()生成的数字作为索引来访问列表、元组、字符串中的值。

 

 

while循环的形式为

while<条件>:

  <语句1>

与for循环不同的是,while语句只有在测试条件为假时才会停止。

 

使用while循环的情况:需要构造一种类似无限循环的程序控制结构或某种不确定运行次数的循环

 

基本数据类型-字符串

字符串的使用

脱除空格 strip()

 

name="li"

 

print(name.center(40,'-'))//打印40个字节,不够的使用‘-’填充,name放置在中间。

 

print(name.find('a'))//查询字母a的下标,若存在,得到下标;若不存在,输出值为-1

 

print(' ' in name )//检查空格是否存在于name中,若存在,显示true,若不存在,则显示false;

 

print(name.capitalize())//将得到的字符串的第一个字母大写。 仅是第一个字母,后续字母不变。

 

msg="hello, this is {name} speaking, please say you {age} for a register"
msg2="hello, this is {0} speaking, please say you {1} for a register"

print(msg.format(name='li',age=33))

print(msg2.format('li','23'))

 

输出结果:

hello, this is li speaking, please say you 33 for a register。

hello, this is li speaking, please say you 23 for a register。

//此为占位符的两种表现形式

 

 

 

age=input('your age :')
if age.isdigit():
age=int(age)
print("enjoy your life")
else:
print('invalid data type')

//isdigit 是判断数据类型是否为数字

 

print(name.islnum()) //断字符变量是否为字母或数字,若是则返回true,否则返回false。

 

print(name.endswith('asd'))//判断字符串是否以asd结尾,若以asd结尾,则返回true,否则返回false;

 

print(name.startswith('asd'))//判断字符串是否以asd开始,若以asd开始,则返回true,否则返回false;

 

print(name.upper().lower())//upper是将所有字母都以大写的方式表现出来,lower是将所有字母都以小写的方式表现出来。

 

 

Name=‘my name is ss’

 

Name.find(“name”)查找Name中“name”的位置

 

Name.isalnum() 如果name为数字,则返回True 否则返回False

 

Name.isalpha() 如果那么为纯因为字符,则返回True,否则返回False

 

Name.isidentifier()判断是否为合法的标识符,若为合法的则返回True,否则返回False

 

Name.istitle()判断是否为一个标题,即是否符合骆驼命令规范

 

Name.isprintable()判断是否为一个可打印文件

 

Name.ljust(50,*)保证一句话长50,如果长度不够,则是用*代替

 

Name.upper()将字母变成大写

 

Name.lower()将字母变成小写

 

Name.lstrip() 去掉左边的空格

 

(直接用字符串)str.maketrans()

 

Name.replace(“l”,“L”)将l替换为L

 

Name.rfind(“*”))从左边寻找某个元素,找到最右边的某个元素如*,并返回其坐标

 

Name.swapcase()将字符串里面存在的大写字母改为小写字母,小写字母改为大写字母。

 

Name.zfill(50)字符串如果不够50位,用0填满。

元组的创建

    ages = (11,22,33,44,55)
    或
    ages = tuple(11,22,33,44,55)

数据的运算操作

 

美高梅手机登录网站 2

 

 

a=8 00001000

b=10 00001010

 

C=a&b =8 (0000 1000) 与运算 相同位数上有相同的数的进行计算

 

C=a | b = 10(0000 1010) 或运算 只要是存在数的即进行运算

 

C=a ^ b =2 (0000 0010) 异或运算 相同为0 不同为1 计入运算

 

 

a=8;

计算机的原码和补码都是其自身

 

转二进制: 01000

 

计算机补码; 01000

 

按位取反: 10111

 

转为原码

 

按位取反: 11000

 

末尾加一: 11001

 

符号位为1 是复数 即为-9

 

 

 

C=a<<2 =32(00100000)集体向左移动两位

 

C=a>>2 =2(00000010)集体向右移动两位

 

 

可变、不可变数据类型和hash

    可变类型                不可变类型
    列表                      数字
                             字符串
                             元组

我们看下什么是可变什么是不可变:

列表

list = [1,2,3,4] id(list) 1602240328712 list.append(5) list [1, 2, 3, 4, 5] id(list) 1602240328712

数字

a = 1 id(a) 1664904208 a = 1 a 2 id(a) 1664904240

字符串

# 示范 1
>>> str = 'hello'
>>> str[1] = 'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
# 示范2
>>> str = 'hello'
>>> id(str)
1602241176272
>>> str  = ' world'
>>> str
'hello world'
>>> id(str)
1602241242992

元组

tup = (1,2,3,4) tup[1] = 3 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment

所以:可变不可变重要的区分在于内存空间地址是否发生改变

字典的操作

 

字典的特性:

1、字典是无序的。

2、key值必须是唯一的,所以是天生去重

 

字典的写法:

info={
1234:{
"name":"liming",
"age":"25",
"gender":"nan"
},
2345:{
"name":"wangsan",
"age":"26",
"gender":"nv"
}
}
print(info)

 

print(info[2345]) 打印 2345 的相关信息

 

info[2345]['qq']="222222222"

//若原字典内没有相关内容,则添加。若有,则更改

 

 

删除信息:

del info(2345)['qq'] //直接使用del命令删除

 

或者是使用.pop()

info[2345].pop('name')

 

获取值

v=info.get(2345)

 

使用一个字典更新另一个字典

 

info2={
1234:{
"name":"liming",
"age":"25",
"gender":"nan"
},
'name':'zhaosi',
}
info.update(info2)

 

 

使用小字典更新大字典的值的时候,遇到相同的值的,更新覆盖;没有则创建

 

 

info.items()

使用此函数,是将字典转变为一个列表

print(info())

print(info.items())

结果为:

dict_items([(1234, {'name': 'liming', 'age': '25', 'gender': 'nan'}), (2345, {'name': 'wangsan', 'age': '26', 'gender': 'nv'})])

{1234: {'name': 'liming', 'age': '25', 'gender': 'nan'}, 2345: {'name': 'wangsan', 'age': '26', 'gender': 'nv'}}

 

 

获取主键

info.keys()

 

获取值

info.values()

 

安全的获取值: info.get("*******")

 

判断字典内是否有值可以使用print(“****” in info)

python2.7中存在如下格式:info.has_key("****")

 

设置默认值

 

info.setdefault(1234567,‘None’)若1234567值不存在,则默认输出None

 

dict.fromkeys([1.2.3.4.56.7.8],'dddd')将前面的值按个取出,然后每个都赋值‘dddd’,初始化一个新的字典,此参数跟copy中的浅copy类似

 

print(dict.fromkeys([1.2.3.4.56.7.8],'dddd'))

结果为:{1: 'dddd', 2: 'dddd', 3: 'dddd', 4: 'dddd', 56: 'dddd', 7: 'dddd'}

 

 

info.popitem()随机删除字典中的一组数据

 

 

遍历字典:

 

for循环:

for k,v in info():

print(k,v)

#效率低,因为要有一个dict to list 的转换过程。

 

for item in info:

print(item,info[item])

#效率较之前循环高很多

 

 

元组的用途

  • 显示的告知别人,此处数据不能修改
  • 数据库连接配置信息等

函数

 

函数的作用:

1、保持数据的一致性

2、保持程序的可扩展性

3、减少代码

 

语法:

def default() #定义函数名

print(“hello") #函数体

 

default()#调用函数

 

 

函数主要组成:

 

1、def

 

2、名称

 

3、函数体 {

“this is a function ”

}

 

4、返回值

 

5、参数

1、普通参数(严格按照顺序,将实际参数赋值给形式参数)

2、默认参数(必须防止在参数列表的最后)

3、指定参数(将实际参数赋值给指定的形式参数)

4、动态参数

* 默认将传入的参数,全部放置在元组中,f1(*[11,22,33,44])

** 默认将传入的参数,全部放置在字典中。f1(**{'k1':"v1","k2","v2"})

5、万能参数, *args, **kwargs

 

传参传的是引用。

 

 

 

函数内部写入的参数为形参,传入的参数为实参

 

函数与过程:

 

过程没有返回值( 没有返回值的函数)

 

函数存在返回值

 

 

 

 

 

默认参数

调用函数的时候,默认参数非必须传递。

形式为:

#定义

def default(ip,port=80):

print(ip "开放的端口为" port)

#调用

default(10.10.10.10)

#展示

res:

10.10.10.10开放的端口为80

 

关键词参数

 

函数赋值时,函数的参数可以使用参数名称来区别,允许不按照顺序写入

形式为:

#定义

def default(ip,port):

print(ip "开放的端口为" port)

#调用

default(port=80,ip=10.10.10.10)

#展示

res:

10.10.10.10开放的端口为80

 

位置参数

调用函数时根据函数定义的参数位置来传递参数。

形式为

#定义

def default(ip,port):

print(ip "开放的端口为" port)

#调用

default(10.10.10.10,80)

#展示

res:

10.10.10.10开放的端口为80

 

PS

1、位置参数必须在关键字参数的前面,关键字参数之间不区分先后顺序

2、一个函数也可以作为参数传入另一个函数内。传入同一个函数则可形成递归函数

 

非固定参数

函数里的参数带* *即代表参数不固定。

* args 接受N个位置参数,转换成元组的形式

#定义

def default(ip,port,*arg):

print(arg)

#调用

default("10.10.10.10","80","445","123","222","213")

#展示

res ('445', '123', '222', '213')

 

 

**kwargs接受N个关键字参数,转换成字典的方式

 

全局变量和局部变量

 

全局变量是在程序一开始定义的变量

 

局部变量是在子程序中定义的变量

 

全局变量作用于整个程序

 

局部变量仅在定义变量的子程序内生效

 

当全局变量和局部变量同名时:

 

在定义局部变量的子程序内,局部变量生效,在其他地方全局变量生效。

 

 

递归参数

 

1、必须有一个明确的结束条件

 

2、每次进入更深一层时,问题规模相对于上次应该有所减少

 

3、递归效率不高,递归层次过多会导致栈溢出

 

 

字符串的定义和创建

字符串是一个有序的字符的集合,用于存储和表示基本的文本信息,''“”“”“中间包含的内存称之字符串

创建:

s = 'Hello XiaoYafei!Hello Python!'

三元运算和lambda表达式

 

 

三元运算符是快速实现if-else的一种形式:

 

if 1==1:

print('OK')

else:

print("False")

 

使用三元运算符实现则为以下模式:

 

print("OK") if 1==1 else "False"

 

 

 

lambda表达式

 

“Lambda 表达式”是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象,是一个匿名函数,即没有函数名的函数。Lambda表达式可以表示闭包。

 

正常形式:

def Test(a):

return a 100

 

a2=Test(2)

 

result:102

 

 

 

lambda表达式:

 

a2=lambda a : a 100

 

res =a2(10)

 

 

divmod

>>> divmod(16,3)
(5, 1)          #5为商,1为余数

变量常量和数据类型

变量,维基百科解释为变数

在计算机科学中,变数是指一个表示某个存在内存中的值的名称。

 

声明变量:

name=“Ming”

此处即声明了一个变量,变量名为 name,name的值为 Ming

 

变量定义的规则:

 

1、变量名只能是 字母、数字或下划线的任意组合

2、变量名的第一个字符不能是数字

3、以下关键字不能声明为变量名

['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

事例:

 

变量的赋值

name = "Alex Li"

name2 = name

print(name,name2)

name = "Jack"

print(name2)

 

 

常量 维基百科解释为常数

常数又称定数,是指一个数值固定不变的常量,与之相反的是变数

 

声明常量:

A=123

但事实上A仍然是一个变量,Python根本没有任何机制保证A不会被改变,所以,用全部大写的变量名表示常量只是一个习惯上的用法。

 

 

数据类型:

在程式设计的类型系统中,数据类型(Data type)是用来约束数据的解释。在编程语言中,常见的数据类型包括原始类型(如:整数、浮点数或字元)、多元组、记录单元、代数数据类型、抽象数据类型、参考类型、类以及函式类型。数据类型描述了数值的表示法、解释和结构,并以算法操作,或是物件在内存中的储存区,或者其它储存装置。

 

在Python中的数据类型主要是有以下几种:

 

1、数字

 

int(整型)  

 在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647

 在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807

Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等。

计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用0x前缀和0-9,a-f表示,例如:0xff00,0xa5b4c3d2,等等。

 

long(长整型)

 

跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。

注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。

 

float(浮点型)

 

浮点数用来处理实数,即带有小数的数字。类似于C语言中的double类型,占8个字节(64位),其中52位表示底,11位表示指数,剩下的一位表示符号。

 

浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是相等的。浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。

 

复数

 

复数是指能写成如下形式的数a bi,这里a和b是实数,i是虚数单位(即-1开根)。在复数a bi中,a称为复数的实部,b称为复数的虚部,i称为虚数单位。当虚部等于零时,这个复数就是实数;当虚部不等于零时,这个复数称为虚数。

 

布尔值(bool)

 

维基百科介绍为真值,又称逻辑值,是指示一个陈述在什么程度上是真的,在计算机编程上多成为布林值、布尔值。

仅有两个值 0或1

 

字符串

 

字符串是以''或""括起来的任意文本,比如'abc',"xyz"等等。请注意,''或""本身只是一种表示方式,不是字符串的一部分,因此,字符串'abc'只有a,b,c这3个字符。如果'本身也是一个字符,那就可以用""括起来,比如"I'm OK"包含的字符是I,',m,空格,O,K这6个字符。

 

字符串主要用于编程,概念说明、函数解释、用法详述见正文,这里补充一点:字符串在存储上类似字符数组,所以它每一位的单个元素都是可以提取的,如s=“abcdefghij”,则s[0]=“a”,s[9]="j"。

 

字符串拼接:字符串的拼接若使用 号,都会在内存中重新开辟一块空间。

 

字符串常用功能:移除空白、分割、长度、索引、切片

 

格式化输出:

name=“123”

print(“ i am %s”) %name

 

其中%s代表字符串, %d 代表整数, %f代表浮点数

 

格式化输出的另一种表现形式

 

name =input("name:")
age=input("age:")
gender=input("gender:")
job=input("job:")

msg='''
----------info:{_name}---------
name:{_name}
age:{_age}
gender:{_gender}
job:{_job}
'''.format(
_name=name,
_age=age,
_gender=gender,
_job=job,
)
print(msg)

 

 

res:

 

----------infozhao---------

name:zhao

age:23

gender:男

job:IT

 

 

列表 列表使用[ ]中括号

 

列表是一种数据项构成的有限序列,即按照一定的线性顺序,排列而成的数据项的集合,在这种数据结构上进行的基本操作包括对元素的的查找,插入,和删除。

 

创建列表: name_list=['this','is','a','list','and','so','on']

print(name_list)

 

元组 元组使用()小括号

 

元组和列表十分类似,只不过元组和字符串一样是不可变的,即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变。

 

创建元组:age=tuple((11,22,33,44,55,66))

print(age)

或者

ages=(11,22,33,44,55,66,77)

print(ages)

 

字典 字典使用{ }大括号

 

可以理解为无序的元组,什么信息都可以存放,

 

创建字典:person = {"name": "mr.wu", 'age': 18}

person = dict({"name": "mr.wu", 'age': 18})

 

GBK和GB2312

很显然,对于我们来说,能在计算机中显示中文才是最重要的,可是在刚才ASCII表里连一个偏旁部首都没有。所以我们需要一张关于中文和数字对应的关系表。之前我们看到,1个字节最多表示256个字符,要处理中文显然一个字节是不够的,所以我们需要采用2个字节来表示,而且还不能和ASCII编码冲突,所以中国制订了GB2312编码,用来把中文编进去。

那么此时,又出现了问题:全世界由一百多种语言,当国外某个游戏或者电影引到中国来时,那么编码需要怎么处理?

Python的定义

Python,维基百科给出了如下介绍:

Python(英国发音:/ˈpaɪθən/ 美国发音:/ˈpaɪθɑːn/),是一种面向对象、解释型的计算机程序语言。它包含了一组功能完备的标准库,能够轻松完成很多常见的任务。它的语法简单,与其它大多数程序设计语言使用大括号不一样,它使用缩进来定义语句块。

此处提到的解释型语言,说的是源代码先翻译成中间代码,再由解释器对中间代码进行解释运行。

 

编译型语言和解释型语言

 

解释型语言写的程序不需要编译,程序在运行时才翻译成机器语言,没执行一次都要翻译一次。可以说是效率比较低。

(此处引用alex事例,)

打个比方:假如你打算阅读一本外文书,而你不知道这门外语,那么你可以找一名翻译,给他足够的时间让他从头到尾把整本书翻译好,然后把书的母语版交给你阅读;或者,你也立刻让这名翻译辅助你阅读,让他一句一句给你翻译,如果你想往回看某个章节,他也得重新给你翻译。 

 

两种方式,前者相当于说的是编译型:首先将源代码编译生成机器语言,再有机器运行机器码,语言如C/C ;而后者就相当于我们要说的解释型:在程序运行的前一刻,还只有源程序而没有可执行程序;而程序每执行到源程序的某一条指令,则会有一个称之为解释程序的外壳程序将源代码转换成二进制代码以供执行,总言之,就是不断地解释、执行、解释、执行……所以,解释型程序是离不开解释程序的。

 

编译型与解释型,两者各有利弊。前者由于程序执行速度快,同等条件下对系统要求较低,因此像开发操作系统、大型应用程序、数据库系统等时都采用它,像C/C 、Pascal/Object Pascal(Delphi)、VB等基本都可视为编译语言,而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言,如Java、JavaScript、VBScript、Perl、Python等等。

 

 

(摘自老蔡博客)

动态类型语言:

动态类型语言是指在运行期间才去做数据类型检查的语言,也就是说,在用动态类型的语言编程时,永远也不用给任何变量指定数据类型,该语言会在你第一次赋值给变量时,在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言,其他的各种脚本语言如VBScript也多少属于动态类型语言。

静态类型语言:

静态类型语言与动态类型语言刚好相反,它的数据类型是在编译其间检查的,也就是说在写程序时要声明所有变量的数据类型,C/C 是静态类型语言的典型代表,其他的静态类型语言还有C#、JAVA等。

 

强类型定义语言和弱类型定义语言

 

(1)强类型定义语言:强制数据类型定义的语言。也就是说,一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是这个数据类型了。举个例子:如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

 

(2)弱类型定义语言:数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。

 

强类型定义语言在速度上可能略逊色于弱类型定义语言,但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外,“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的!

例如:Python是动态语言,是强类型定义语言(类型安全的语言); VBScript是动态语言,是弱类型定义语言(类型不安全的语言); JAVA是静态语言,是强类型定义语言(类型安全的语言)。

 

总结可得,Python是一门动态解释性的强类型定义的语言。

 

Unicode

因此,Unicode应运而生,Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。

Unicode标准也在不断发展,但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符,就需要4个字节)。现代操作系统和大多数编程语言都直接支持Unicode。
现在,捋一捋ASCII编码和Unicode编码的区别:

ASCII编码是1个字节,而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65,二进制的01000001;

字符0用ASCII编码是十进制的48,二进制的00110000;

汉字“中”已经超出了ASCII编码的范围,用Unicode编码是十进制的20013,二进制的01001110 00101101。

你可以猜测,如果把ASCII编码的A用Unicode编码,只需要在前面补0就可以,因此,A的Unicode编码是00000000 01000001。

新的问题又出现了,如果都改成Unicode编码的话,乱码问题就会消失,那么随之而来的就是:如果你写的文本基本上都是英文的话,用Unicode编码要比ASCII编码需要多一倍的空间,在存储和传输上就十分不划算了。

集合

元组的常见操作

索引

ages = (11,22,33,44,55) ages[0] 11 ages[3] 44

切片

ages (11, 22, 33, 44, 55) ages[1:2] (22,) ages[1:] (22, 33, 44, 55) ages[::2] (11, 33, 55)

循环

ages (11, 22, 33, 44, 55) for i in ages: ... print(i) ... 11 22 33 44 55

len() 长度

ages (11, 22, 33, 44, 55) len(ages) 5

in 包含

ages (11, 22, 33, 44, 55) 11 in ages True

最后讲解元组的修改

ages (11, 22, 33, 44, 55) ages[1] = 'libaba' Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment #立马报错提示不能修改

UTF-8

所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:

    字符  ASCII           Unicode                 UTF-8
    A          01000001     00000000 01000001              01000001
    中              x        01001110 00101101       11100100 10111000 10101101

从上图来看,UTF-8编码有一个额外的好处,就是ASCII编码实际上可以看作为UTF-8的一部分,所以,大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

搞清楚了ASCII和、UnicodeUTF-8的区关系,可以总结一下计算机系统通用的字符编码工作方式:
在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者是需要传输的时候,就转换为UTF-8编码;

用记事本编辑的时候,从文件读取的UTF-8字符被转换成Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换成UTF-8保存到文件;

  • windows默认是GBK
  • MacOSLinux默认为UTF-8

  • Python2编码为ASCII

  • Python3编码为UTF-8

元组的定义

与列表相似,只不过[]换成了(),我们一般称元组为制度列表

进制转换

虽然计算机只认识二进制,但是为了迎合我们的习惯,python的数字默认还是十进制。还提供了一些方法来帮助我们做转换,比如是进制转换为二进制使用[`bin] 方法,在转换结果面前还会加上0b表示是一个二进制的数。

>>> num = 132
>>> bin(num)
'0b10000100'

既然十进制可以转换为二进制,那么其实使用同样的原理也可以转换为其他进制,python也为我们提供了十进制转换成八进制和十六进制的方法,分别是oct和hex。八进制前面以0o表示 ,十六进制以0表示

>>> num = 129
>>> oct(num)
'0o201'
>>> hex(num)
'0x81'

基本数据类型-列表

装水桶法

先把他们代表的值一次写出来,然后再根据10进制的值把数填到相应位置,就好了~~~
十进制转二进制的方法相同,只要对照二进制为1的那一位对应的十进制值相加就可以了。

        128     64      32      16      8       4       2        1

20       0       0       0       1      0       1       0        0   
200      1       1       0       0      1       0       0        0

为什么要用浮点数

浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,
一个浮点数的小数点位置是可变的,比如,
1.23x109和12.3x108是相等的。
浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代:
1.23*109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。
整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的而浮点数运算则可能会有四舍五入的误差。

列表的特点

特征:

  • 可存放多个值
  • 按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序
    list    =       ['张三','李四','校长']
    索引                0      1      2
  • 可以修改指定索引的值,可变

Python基础第二章

  • 二进制
  • 字符编码
  • 基本数据类型-数字
  • 基本数据类型-字符串
  • 基本数据类型-列表
  • 基本数据类型-元组
  • 可变、不可变数据类型和hash
  • 基本数据类型-字典
  • 基本数据类型-集合

元组的特征

  • 可存放多个值
  • 不可变,元组本身不可变,但是如果元组还存放其余可变类型的数据,则是可变的
  • 按照从左到右的顺序定义元组元素,下表从0开始顺序访问,有序

整型

Python中的整数属于int类型,默认用十进制表示,此外也支持二进制,八进制,十六进制表示方式。

取余运算

>>> 16%5
1

二进制

二进制是计算技术中采用的一种进制。二进制数由0和1两个数码组成,它的基数为2,进制规则是“逢二进一”,由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统,数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关,用“开”代表1,“关”代表0。

字符串的特性与常用操作

hash

  • 就是将任意长度的字符串,通过散列算法,变成固定长度的输出,该输出就是散列值
  • 这种转换被称为压缩映射,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来却东唯一输入值
  • 简单的来说,就是将一种任意长度的消息压缩到固定长度的消息摘要的函数

特征

  • hash值的计算过程是依据这个值的一些特征进行计算的,要求被hash值是固定的,因此被hash是不可变的

用途

  • 文件签名
  • md5加密(无法反解)
  • 密码验证

语法

hash('xiaoyafei') -1204730465301308513

用过例子来说明关系运算

  自定义购买iphone7和iphone8的人
    i7 = {'xiaozhang','xiangwang','xiaoli'}
    i8 = {'xiaoli','laozhao','laowang'}

交集 intersection()

# 两个都购买的人
>>> l_p  = i7&i8
>>> l_p
{'xiaoli'}

# 也可以使用
>>> i7
{'xiaoli', 'xiangwang', 'xiaozhang'}
>>> i8
{'xiaoli', 'laozhao', 'laowang'}
>>> i7.intersection(i8)
{'xiaoli'}

差集 difference()

# 只购买iphone7的人
>>> i7.difference(i8)
{'xiangwang', 'xiaozhang'}

# 只购买iphone8的人
>>> i8.difference(i7)
{'laowang', 'laozhao'}

并集 union()

# 购买iphone7和iphone8的人
>>> i7.union(i8)
{'laozhao', 'laowang', 'xiaozhang', 'xiaoli', 'xiangwang'}
>>> i8.union(i7)
{'laozhao', 'laowang', 'xiaozhang', 'xiaoli', 'xiangwang'}

# 也可以使用
>>> i7|i8
{'laozhao', 'laowang', 'xiaozhang', 'xiaoli', 'xiangwang'}

对称差集,把不交集的地方取出来 symmetric_difference

# 可以理解为: 只买了i7和只买了i8的人
>>> i7 = {'xiaozhang','xiangwang','xiaoli'}
>>> i8 = {'xiaoli','laozhao','laowang'}
>>> i7.symmetric_difference(i8)
{'laowang', 'xiaozhang', 'xiangwang', 'laozhao'}

子集

# 可以理解成北京市是中国的子集,而中国是北京市的超集
>>> s = {1,2,3}
>>> s2 = {1,2,3,4,5,6}
>>> s.issubset(s2)
True

# 也可以使用
>>> s2>s
True

超集

print(s,s2) {1, 2, 3} {1, 2, 3, 4, 5, 6} s2.issuperset(s) True

# 也可以使用
>>> s<s2
True

判断两个集合是不是不相交 isdisjoint()

set1 = {1,2,3} set2 = {7,8,9} set1.isdisjoint(set2) True

获取差集并重新赋值给set1

set1 {1, 2, 3, -1, -2} set2 {1, 2, 3, 7, 8, 9} set1.difference(set2) {-1, -2} set1.difference_update(set2) set1 {-1, -2} set2 {1, 2, 3, 7, 8, 9}

基本数据类型-字典

列表的创建

list_test = ['张三','李四','xiaoyafei',22]
或
list_test = list(['zhangsan','lisi','wanger'])

深拷贝和浅拷贝

这里重新定义了列表!

# 把list复制给list3
>>> list
['zhangsan', 'xiaoyafei']
>>> list3 = list
>>> id(list)            #查看到列表的ID号是一样的
2661905413128
>>> id(list3)
2661905413128
>>> list[1] = 'lidapeng'    #所以可以理解为这个列表是公用的
>>> list3
['zhangsan', 'lidapeng']
>>> list
['zhangsan', 'lidapeng']

让我们首先来回顾下变量:

    name = 'xiaoyafei'      #代表在内存中开辟一个新的空间用来存放这个值xiaoyafei,变量名为name
    name2 = name        #代表着name2指向了这个空间地址,这个空间地址的值是xiaoyafei
    >>> id(name)        #内存空间地址相同,即可证明这一点
    2292157129392
    >>> id(name2)
    2292157129392

那么我们希望list能和list4分开,那么我们就需要使用copy()函数:

# 此时的list和list2列表是完全独立的
>>> list = ['zhangsan','lisi']
>>> list
['zhangsan', 'lisi']
>>> list2 = list.copy()     #list调用copy()函数,copy给list2
>>> list2
['zhangsan', 'lisi']
>>> list[1] = 'xiaoyafei'
>>> list2
['zhangsan', 'lisi']

# 查看两个列表的ID号
>>> id(list)
2661905413128
>>> id(list2)
2661906326600 

知识点2--浅copy

# 重新定义list和list2函数,然后使用append将list2添加到list中
>>> list = ['zhangsan','lisi','wangwu']
>>> list2 = ['beijing','shanghai','guangzhou']
>>> list.append(list2)
>>> list
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai', 'guangzhou']]

# 这个时候我们使用copy()函数
>>> list3 = list.copy()
>>> list3
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai', 'guangzhou']]
>>> id(list)        #查看内存地址后发现是不一样的,那么我们对list进行修改的话,list3也会修改吗?
1708042040328
>>> id(list3)
1708042953736

# 我们来修改测试一下
>>> list[1] = 'xixihaha'        #对list列表下标为1的元素进行修改,发现 list3没有继续修改
>>> list
['zhangsan', 'xixihaha', 'wangwu', ['beijing', 'shanghai', 'guangzhou']]
>>> list3
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai', 'guangzhou']]

# 让我们再来修改一下看看
>>> list[3][0] = '珠海'
>>> list
['zhangsan', 'xixihaha', 'wangwu', ['珠海', 'shanghai', 'guangzhou']]
>>> list3
['zhangsan', 'lisi', 'wangwu', ['珠海', 'shanghai', 'guangzhou']]
# 奇怪的事情发生了,为什么list3也会跟着修改呢?可刚刚我们测试的时候是没有修改的啊

# 原因就是
>>> id(list[3])     #我们发现在列表中的子列表在内存中的空间地址是一模一样的,难不成会跟着修改呢
1708042061768
>>> id(list3[3])
1708042061768

知识点3--深copy

# 在这里,我们又重新定义了列表
>>> list = ['zhangsan','lisi','wangwu']
>>> list2 = ['beijing','shanghai']
>>> list.append(list2)
>>> list
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai']]

# 如果想使用深copy的话,需要导入python的工具包copy
>>> list
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai']]
>>> import copy     #导入python工具包
>>> list3 = copy.deepcopy(list)
>>> list3
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai']]
>>> id(list)
1255945745416
>>> id(list3)
1255948140680

# 让我们来试一下
>>> list[1] = 'xixihaha'        #对list列表下标为1的元素进行修改,发现list3并无修改
>>> list
['zhangsan', 'xixihaha', 'wangwu', ['beijing', 'shanghai']]
>>> list3
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai']]

# 再来试一下
>>> list[3][0] = '珠海'
>>> list
['zhangsan', 'xixihaha', 'wangwu', ['珠海', 'shanghai']]
>>> list3
['zhangsan', 'lisi', 'wangwu', ['beijing', 'shanghai']]
那么为什么list3没有随着list的改变再修改呢?
原因看下面

深copy和浅copy的区别

  • 浅copy不会重新创建内存地址,内容指向之前的空间地址,如果浅copy对象中有其他子对象,那么在修改这个子对象的时侯子对象的内容就会改变
  • 深copy就是新建一个对象重复分配空间地址,复制对象的内容

那么我们可以理解成,在list这个列表中,存在着子列表,那么我们对子列表之外的元素进行修改时,另一个对象不会去修改,但是在我们修改子列表的元素的时候,另一个列表就会跟着修改

集合的创建

set = {'xiaozhang','laowang','dage'}
有人可能会说了着明明是一个字典,那我们用type()函数试一下
>>> set = {'xiaozhang','laowang','dage'}
>>> type(set)
结果为:class 'set'>
原来当{}里为空就是一个字典,如果有东西就是集合

由一个或者多个确定的元素所构成的整体叫做集合

集合中的元素由三个特征

  • 确定性(元素必须可hash)
  • 互异性(去重)
  • 无序性(集合中的元素没有先后之分)

注意:集合存在的意义就是在于去重和关系运算

布尔型

bool型只有两个值:True和False

之所以将bool值归类为数字,是因为我们也习惯用1表示True,0表示False

字典的常见操作

增加

info {'stu1': 'zhangsan', 'stu2': 'lisi', 'stu3': 'wangwu'} info['stu4'] = 'xixihaha' info {'stu1': 'zhangsan', 'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'}

修改

info {'stu1': 'zhangsan', 'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'} info['stu1'] = 'student1' #修改的是value info {'stu1': 'student1', 'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'}

集合去重

# 集合会自动去重
>>> s = {1,1,2,2,3,3,4,4}
>>> s
{1, 2, 3, 4}

将列表转换成集合

list = [1,2,3,4,5,6,7] s = set(list) s {1, 2, 3, 4, 5, 6, 7}

in 查找表示准语法

info {'stu1': 'student1', 'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'} 'stu1' in info True

获取value值,存在则返回,不存在不返回任何信息

info {'stu1': 'student1', 'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'} info.get('stu1') 'student1'

# 存在则返回,不存在则报错
>>> info['stu1']
'student1'

pop() 删除

info {'stu1': 'student1', 'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'} info.pop('stu1') #会返回删除的信息 'student1' info {'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha'}

popitem() 随机删除,如果数据量足够大那么就是无序的

info {'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha', 'stu1': 'zhangsan', 'stu5': 'lihaha'} info.popitem()
('stu5', 'lihaha') info.popitem() ('stu1', 'zhangsan')

丢弃discard

s {1, 2, 3, 4, 5, 6, 7} s.discard(6) s.discard(10) #即使没有也不会报错

del 删除

person {'name': 'zhangsan'} del person person Traceback (most recent call last): File "", line 1, in NameError: name 'person' is not defined

清空clear()

s {1, 2, 3, 4, 5, 7} s.clear() s set()

打印所有key

info {'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha', 'stu5': 'lihaha', 'stu6': 'zhangsan'} info.keys() dict_keys(['stu2', 'stu3', 'stu4', 'stu5', 'stu6'])

打印所有value

info.values() dict_values(['lisi', 'wangwu', 'xixihaha', 'lihaha', 'zhangsan'])

打印key和value变成元组,把字典转成列表

info {'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha', 'stu5': 'lihaha', 'stu6': 'zhangsan'} info.items() dict_items([('stu2', 'lisi'), ('stu3', 'wangwu'), ('stu4', 'xixihaha'), ('stu5', 'lihaha'), ('stu6', 'zhangsan')])

update 把两个字典合并成一个字典,key有重复则覆盖,没有则新建

info {'stu2': 'lisi', 'stu3': 'wangwu', 'stu4': 'xixihaha', 'stu5': 'lihaha', 'stu6': 'zhangsan'} info2 {'stu2': '北京', 'stu8': '上海', 'stu9': '广州'} info.update(info2) info {'stu2': '北京', 'stu3': 'wangwu', 'stu4': 'xixihaha', 'stu5': 'lihaha', 'stu6': 'zhangsan', 'stu8': '上海', 'stu9': '广州'}

setdefault创建,存在则不操作,不存在则创建

info2 {'stu2': '北京', 'stu8': '上海', 'stu9': '广州'} info2.setdefault(2,'new2') 'new2' info2 {'stu2': '北京', 'stu8': '上海', 'stu9': '广州', 2: 'new2'}

fromkeys 不会添加到原来字典当中,而是直接弹出

info.fromkeys(['a','b','c','d'],['xiaoyafei']) {'a': ['xiaoyafei'], 'b': ['xiaoyafei'], 'c': ['xiaoyafei'], 'd': ['xiaoyafei']}

字典的循环

info {'stu2': '北京', 'stu3': 'wangwu', 'stu4': 'xixihaha', 'stu5': 'lihaha', 'stu6': 'zhangsan', 'stu8': '上海', 'stu9': '广州'} for i in info: ... print(i,info[i]) ... stu2 北京 stu3 wangwu stu4 xixihaha stu5 lihaha stu6 zhangsan stu8 上海 stu9 广州

# 还有一种方法,但是很低效,因为要把字典转换成列表
>>> for k,v in info.items():
...     print(k,v)
...
stu2 北京
stu3 wangwu
stu4 xixihaha
stu5 lihaha
stu6 zhangsan
stu8 上海
stu9 广州

ASCII码

ASCII表

ASCII(American Standard Code for Information Interchange,美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统,主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统,并等同于国际标准ISO/IEC 646。

由于计算机是美国人发明的,因此,最早只有127个字母被编码到计算机里,也就是大小写英字母、数字和一些符号,这个编码表被称为ASCII编码,比如大写字母 A的编码是65,小写字母 z的编码是122。后128个称为扩展ASCII码。

那现在我们就知道了上面的字母符号和数字对应的表是早就存在的。那么根据现在有的一些十进制,我们就可以转换成二进制的编码串。
比如:

一个空格对应的数字是0     翻译成二进制就是0(注意字符0和整数0是不同的)
一个对勾√对应的数字是251  翻译成二进制就是11111011

提问:如果我们要打印两个空格和一个对勾,写成二进制就应该是[`0011111011],但是问题来了,我们怎么知道从哪到哪是一个字符呢?聪明的人类就想出了一个解决办法,既然一共就这255个字符,那最长的也不过11111111八位,不如就把所有的二进制都转换成8位的,不足的用0来替换。

这样一来,刚刚的两个空格一个对勾就写作[`000000000000000011111011],读取的时候只要每次读8个字符就能知道每个字符的二进制值啦。

在这里,[`每一位0或者1所占的空间单位为bit(比特)],这是计算机中最小的表示单位。每8个bit组成一个字节,这是计算机最小的存储单位。

    bit                 位,计算机中最小的表示单位
    8bit = 1bytes       字节,最小的存储单位,1bytes缩写为1B
    1KB = 1024KB
    1MB = 1024KB
    1GB = 1024MB
    1TB = 1024GB
    1PB = 1024TB
    ......

那么,到了现在学完了ASCII码,作为一名英文程序员来说,基本是圆满了,但是作为一名中国程序员,是不是觉得还少了点什么?

常见操作

字符串是不可变的?

a = 'xiaoyafei' #变量的复制,即是将这个变量指向内存空间中的地址 id(a) #查看到此时变量a的空间地址 139742341438256
a = 'xiaobaba' #对a进行修改 id(a) #再次查看变量a的空间地址 139742341436848

为什么说字符串是不可变的呢?我们可以很清晰的看到变量a两次的空间地址并不一样,是因为在我们修改时,把a指向了另一个内存空间地址,而xiaoyafei这个值将会被垃圾回收

swapcase() 小写变大写,大写变小写

str = 'Hello World' str.swapcase() 'hELLO wORLD'

capitalize() 首字母大写,其余全变成小写

str = 'helLo WORLD' str.capitalize() 'Hello world'

casefold() 把大写都全部换成小写

str = 'HELLO WORLD!' str.casefold() 'hello world!'

center() 返回字符串在中间,两边以字符填充

str = 'hello world' str.center(50,'') '**hello world**'

count() 统计字符出现的次数

str = 'abcdfdawadsqasacsasasaa' str.count('a') 9

#也可以指定从哪开始到哪结束

str.count('a',0,10) 3

endswith() 判断是否以某字符串结尾,返回True或False

str = 'hello world!python' str.endswith('python') True str.endswith('hello') False

expandtabs() 扩展tab键

a = 'atb' a 'atb' print(a) a b a.expandtabs(20) 'a b'

find() 查找,找到则返回索引,找不到则返回-1

name = 'xiaoyafei' name.find('o') 3 name.find('g') -1

#也可以规定搜索范围

name.find('a',4,9) 5

format() 格式化字符串

info = 'my name is {0},i am {1} years old.' info.format('xiaoyafei',22) 'my name is xiaoyafei,i am 22 years old.'

#也可以使用变量

info = 'my name is {name},my age is {age}.' info.format(name = 'xiaoyafei',age=22) 'my name is xiaoyafei,my age is 22.'

index() 返回索引值,找不到则报错

s = 'hello tairan and welcome!' s.index('t') 6 s.index('g') Traceback (most recent call last): File "", line 1, in ValueError: substring not found

#也可以根据开始和终止位置查找

s 'hello tairan and welcome!' s.index( ... 'a') 7

isalnum() 判断是不是阿拉伯字符(数字和字母)

a = '123abc' a.isalnum() True b = '123!abc' b.isalnum() False

isalpha() 判断是否只包含字木,不包含数字

a = 'abc123' a.isal a.isalnum( a.isalpha(
a.isalpha() False b = 'abcdefg' b.isalpha() True

decimal() 判断是否是整数

a = '111' a.isdecimal() True

#第二种方法

a.isdigit() True

isidentifier() 判断字符串的值是不是可以使用的变量名

a = '111' a.isidentifier() False #数字不能作为变量名 b = 'Menu' b.isidentifier() True

islower() 判断字符串是不是都是小写

str = 'HelloWorld' str.islower() False str2 = 'helloworld' str2.islower() True

isnumeric() 判断是不是只有数字在里面

a = '1233' a.isnumeric() True b = 'abc123' b.isnumeric() False

isspace() 判断是不是空格

a = ' ' a.isspace() True

title() 变成title,即每一个单词的首字母都是大写

str = 'hello world python tairan ' str.title() 'Hello World Python Tairan '

upper() 将字符串全部转换成大写
python >> namew = 'xiaoyafei' >> namew.upper() 'XIAOYAFEI'
join() 把列表变成字符串后,以指定的字符串来区分列表里的元素

names = ['lipeng','likun','lipeng'] str = '---' str.join(names) 'lipeng---likun---lipeng'

ljust() 从左边开始,总长度不够的话用指定的字符去代替

name = 'xiaoyafei' name.ljust(50,'') 'xiaoyafei__'

lower() 把字符串都变成小写

name = 'XIAOYAFEI' name.lower() 'xiaoyafei'

strip() 去除两边的空格和换行

str = 'n hello world ' str.strip() 'hello world'

# lstrp只去左边不去右边
# rstrip只去右边不去左边

maketrans() 密码表

str_in = '1234567890' #这个为原本的 str_out = '!@#$%^&()' #这个是输出后的 table = str.maketrans(str_in,str_out) #将两张表进行对应关系 s = '572428582' #重新输入的 s.translate(table) #输出后的密码表 '%&@$@%*@'

partition() 把整个字符串以自己想要的进行切割

str 'hello world' str.partition('o') ('hell', 'o', ' world')

replace() 替换,默认全部更换掉

s = 'hello world,hello tairan' s.replace('llo','LLO') 'heLLO world,heLLO tairan'

#只更换一次

s 'hello world,hello tairan' s.replace('llo','LLO',1) 'heLLO world,hello tairan'

rsplit() 从右边开始将字符串以指定的字符切割

s 'hello world,hello tairan'

s.rsplit('o') ['hell', ' w', 'rld,hell', ' tairan']

splitlines() 按行来分,格式为列表

str = 'anbncndn' str.splitlines() ['a', 'b', 'c', 'd']

startswith() 判断以指定字符开始

str 'hello,xiaoyafei' str.startswith('hel') True

zfill() 从左开始,以指定字符代替,(右边为原字符串)

str = 'hello tairan' str.zfill(50) '00000000000000000000000000000000000000hello tairan'

列表的定义和创建

定义:[ ]内以逗号分隔,按照索引,存放各种数据类型,每一个位置代表一个元素

二进制与十进制的转换

二进制的第n位代表的十进制值都刚好遵循着2的n次方这个规律

复数

复数complex是由实数和虚数组成的。

要了解复数,其实关于复数还需要先了解虚数。虚数(就是虚假不实的数):平方为复数的数叫做虚数。

复数是指能写成如下形式的数a bi,这里a和b是实数,i是虚数单位(即-1开根)。在复数a bi中,a称为复数的实部,b称为复数的虚部(虚数是指平方为负数的数),i称为虚数单位。

当虚部等于零时,这个复数就是实数;当虚部不等于零时,这个复数称为虚数。

注,虚数部分的字母j大小写都可以。

特性

1.按照从左往右的顺序定义字符集合,下表从0开始顺序访问,有序

    str      =           hello
    索引                 01234

补充:
1.字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所有字符均取消特殊意义,在引导前面添加r,如:
python name = r'pythotn'

  • 使用ctrl加上鼠标左键可以查看源码
class str(object):
    """
    str(object='') -> str
    str(bytes_or_buffer[, encoding[, errors]]) -> str

    Create a new string object from the given object. If encoding or
    errors is specified, then the object must expose a data buffer
    that will be decoded using the given encoding and error handler.
    Otherwise, returns the result of object.__str__() (if defined)
    or repr(object).
    encoding defaults to sys.getdefaultencoding().
    errors defaults to 'strict'.
    """
    def capitalize(self): # real signature unknown; restored from __doc__
        """
        S.capitalize() -> str

        Return a capitalized version of S, i.e. make the first character
        have upper case and the rest lower case.
        """
        return ""

    def casefold(self): # real signature unknown; restored from __doc__
        """
        S.casefold() -> str

        Return a version of S suitable for caseless comparisons.
        """
        return ""

    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.center(width[, fillchar]) -> str

        Return S centered in a string of length width. Padding is
        done using the specified fill character (default is a space)
        """
        return ""

    def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.count(sub[, start[, end]]) -> int

        Return the number of non-overlapping occurrences of substring sub in
        string S[start:end].  Optional arguments start and end are
        interpreted as in slice notation.
        """
        return 0

    def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
        """
        S.encode(encoding='utf-8', errors='strict') -> bytes

        Encode S using the codec registered for encoding. Default encoding
        is 'utf-8'. errors may be given to set a different error
        handling scheme. Default is 'strict' meaning that encoding errors raise
        a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
        'xmlcharrefreplace' as well as any other name registered with
        codecs.register_error that can handle UnicodeEncodeErrors.
        """
        return b""

    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.endswith(suffix[, start[, end]]) -> bool

        Return True if S ends with the specified suffix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        suffix can also be a tuple of strings to try.
        """
        return False

    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
        """
        S.expandtabs(tabsize=8) -> str

        Return a copy of S where all tab characters are expanded using spaces.
        If tabsize is not given, a tab size of 8 characters is assumed.
        """
        return ""

    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.find(sub[, start[, end]]) -> int

        Return the lowest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.

        Return -1 on failure.
        """
        return 0

    def format(self, *args, **kwargs): # known special case of str.format
        """
        S.format(*args, **kwargs) -> str

        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces ('{' and '}').
        """
        pass

    def format_map(self, mapping): # real signature unknown; restored from __doc__
        """
        S.format_map(mapping) -> str

        Return a formatted version of S, using substitutions from mapping.
        The substitutions are identified by braces ('{' and '}').
        """
        return ""

    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.index(sub[, start[, end]]) -> int

        Return the lowest index in S where substring sub is found, 
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.

        Raises ValueError when the substring is not found.
        """
        return 0

    def isalnum(self): # real signature unknown; restored from __doc__
        """
        S.isalnum() -> bool

        Return True if all characters in S are alphanumeric
        and there is at least one character in S, False otherwise.
        """
        return False

    def isalpha(self): # real signature unknown; restored from __doc__
        """
        S.isalpha() -> bool

        Return True if all characters in S are alphabetic
        and there is at least one character in S, False otherwise.
        """
        return False

    def isdecimal(self): # real signature unknown; restored from __doc__
        """
        S.isdecimal() -> bool

        Return True if there are only decimal characters in S,
        False otherwise.
        """
        return False

    def isdigit(self): # real signature unknown; restored from __doc__
        """
        S.isdigit() -> bool

        Return True if all characters in S are digits
        and there is at least one character in S, False otherwise.
        """
        return False

    def isidentifier(self): # real signature unknown; restored from __doc__
        """
        S.isidentifier() -> bool

        Return True if S is a valid identifier according
        to the language definition.

        Use keyword.iskeyword() to test for reserved identifiers
        such as "def" and "class".
        """
        return False

    def islower(self): # real signature unknown; restored from __doc__
        """
        S.islower() -> bool

        Return True if all cased characters in S are lowercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

    def isnumeric(self): # real signature unknown; restored from __doc__
        """
        S.isnumeric() -> bool

        Return True if there are only numeric characters in S,
        False otherwise.
        """
        return False

    def isprintable(self): # real signature unknown; restored from __doc__
        """
        S.isprintable() -> bool

        Return True if all characters in S are considered
        printable in repr() or S is empty, False otherwise.
        """
        return False

    def isspace(self): # real signature unknown; restored from __doc__
        """
        S.isspace() -> bool

        Return True if all characters in S are whitespace
        and there is at least one character in S, False otherwise.
        """
        return False

    def istitle(self): # real signature unknown; restored from __doc__
        """
        S.istitle() -> bool

        Return True if S is a titlecased string and there is at least one
        character in S, i.e. upper- and titlecase characters may only
        follow uncased characters and lowercase characters only cased ones.
        Return False otherwise.
        """
        return False

    def isupper(self): # real signature unknown; restored from __doc__
        """
        S.isupper() -> bool

        Return True if all cased characters in S are uppercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

    def join(self, iterable): # real signature unknown; restored from __doc__
        """
        S.join(iterable) -> str

        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.
        """
        return ""

    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.ljust(width[, fillchar]) -> str

        Return S left-justified in a Unicode string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""

    def lower(self): # real signature unknown; restored from __doc__
        """
        S.lower() -> str

        Return a copy of the string S converted to lowercase.
        """
        return ""

    def lstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.lstrip([chars]) -> str

        Return a copy of the string S with leading whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

    def maketrans(self, *args, **kwargs): # real signature unknown
        """
        Return a translation table usable for str.translate().

        If there is only one argument, it must be a dictionary mapping Unicode
        ordinals (integers) or characters to Unicode ordinals, strings or None.
        Character keys will be then converted to ordinals.
        If there are two arguments, they must be strings of equal length, and
        in the resulting dictionary, each character in x will be mapped to the
        character at the same position in y. If there is a third argument, it
        must be a string, whose characters will be mapped to None in the result.
        """
        pass

    def partition(self, sep): # real signature unknown; restored from __doc__
        """
        S.partition(sep) -> (head, sep, tail)

        Search for the separator sep in S, and return the part before it,
        the separator itself, and the part after it.  If the separator is not
        found, return S and two empty strings.
        """
        pass

    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
        """
        S.replace(old, new[, count]) -> str

        Return a copy of S with all occurrences of substring
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""

    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.rfind(sub[, start[, end]]) -> int

        Return the highest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.

        Return -1 on failure.
        """
        return 0

    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.rindex(sub[, start[, end]]) -> int

        Return the highest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.

        Raises ValueError when the substring is not found.
        """
        return 0

    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.rjust(width[, fillchar]) -> str

        Return S right-justified in a string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""

    def rpartition(self, sep): # real signature unknown; restored from __doc__
        """
        S.rpartition(sep) -> (head, sep, tail)

        Search for the separator sep in S, starting at the end of S, and return
        the part before it, the separator itself, and the part after it.  If the
        separator is not found, return two empty strings and S.
        """
        pass

    def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.rsplit(sep=None, maxsplit=-1) -> list of strings

        Return a list of the words in S, using sep as the
        delimiter string, starting at the end of the string and
        working to the front.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified, any whitespace string
        is a separator.
        """
        return []

    def rstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.rstrip([chars]) -> str

        Return a copy of the string S with trailing whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.split(sep=None, maxsplit=-1) -> list of strings

        Return a list of the words in S, using sep as the
        delimiter string.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified or is None, any
        whitespace string is a separator and empty strings are
        removed from the result.
        """
        return []

    def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
        """
        S.splitlines([keepends]) -> list of strings

        Return a list of the lines in S, breaking at line boundaries.
        Line breaks are not included in the resulting list unless keepends
        is given and true.
        """
        return []

    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.startswith(prefix[, start[, end]]) -> bool

        Return True if S starts with the specified prefix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        prefix can also be a tuple of strings to try.
        """
        return False

    def strip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.strip([chars]) -> str

        Return a copy of the string S with leading and trailing
        whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

    def swapcase(self): # real signature unknown; restored from __doc__
        """
        S.swapcase() -> str

        Return a copy of S with uppercase characters converted to lowercase
        and vice versa.
        """
        return ""

    def title(self): # real signature unknown; restored from __doc__
        """
        S.title() -> str

        Return a titlecased version of S, i.e. words start with title case
        characters, all remaining cased characters have lower case.
        """
        return ""

    def translate(self, table): # real signature unknown; restored from __doc__
        """
        S.translate(table) -> str

        Return a copy of the string S in which each character has been mapped
        through the given translation table. The table must implement
        lookup/indexing via __getitem__, for instance a dictionary or list,
        mapping Unicode ordinals to Unicode ordinals, strings, or None. If
        this operation raises LookupError, the character is left untouched.
        Characters mapped to None are deleted.
        """
        return ""

    def upper(self): # real signature unknown; restored from __doc__
        """
        S.upper() -> str

        Return a copy of S converted to uppercase.
        """
        return ""

    def zfill(self, width): # real signature unknown; restored from __doc__
        """
        S.zfill(width) -> str

        Pad a numeric string S with zeros on the left, to fill a field
        of the specified width. The string S is never truncated.
        """
        return ""

浮点型

浮点数是属于有理数中某特定子集的数的数字表示,在计算机中用以近似表示任意某个实数。具体的说,这个实数由一个整数或定点数(即尾数)乘以某个基数(计算机中通常是2)的整数次幂得到,这表示方法类似于基数为10的科学计数法。

python的浮点数就是数学中的小数(有限小数和无限循环小数)

在运算中,整数与浮点数运算的结果也是一个浮点数

字典的定义

字典是Python语言中唯一的映射类型。

>>> info = {
...     'stu1':'zhangsan',
...     'stu2':'lisi',
...     'stu3':'wangwu'
... }

# 也可以使用另一种方法
>>> person = dict({'name':'zhangsan'})

字典的特征

  • key-value结构
  • key必须可hash,且必须为不可变类型必须唯一
  • 可存放任意多个值可修改可以不唯一
  • 无序

基本数据类型-元组

本文由美高梅4858官方网站发布,转载请注明来源

关键词: python 笔记