都可以：
print('a''b')
print('a' 'b')
print('a'+'b')
print('a','b')常用！
数据类型
Python3 中有六个标准的数据类型：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
可变与不可变：
在 python 中，类型属于对象，变量是没有类型的：
a=[1,2,3]
a="Runoob"
以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，
而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
数据类型无非搞清楚：定义、赋值、取值
1-Number：
Python3 支持 int、float、bool、complex（复数）。
在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
int float conflex (值不可变，指向值的指针变化）
a = [[1, 2, 3], [4, 5, 6]]#数组定义
a[1][2]=10
#利用numpy创建数组
import numpy as np；a=np.array([[1,2,3],[4,5,6]])；#这是一个两维数组 访问：a[:,0]
a, b, c, d = 20, 5.5, True, 4+3j
a=b=1
del a
2 / 4 # 除法，得到一个浮点数
2 // 4 # 除法，得到一个整数
2 ** 5 # 乘方
#一个变量可以通过赋值指向不同类型的对象。
a=True
a=10
#在混合计算时，Python会把整型转换成为浮点数。
a=complex(1,2)#(1+2j)
b=complex(1)#(1+0j)
2-String -序列
（值不可变）
s1='abcde'
s111='''1232'''
s1[1]='k'#错误
print(s1[1:-1])#倒数第二个
print(s1[-1])#倒数第一个
#如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r
s2=s1+s1
s3=s1*2
s4 = "a" + 'b' * 3
s5=s1[2:3:1]#没有字符类型，只有字符串类型
print(s5[0:-1]) # 输出第一个到倒数第二个的所有字符
print(s5[0]) # 输出字符串第一个字符
print(s5[2:5]) # 输出从第三个开始到第五个的字符
print(s5[2:]) # 输出从第三个开始的后的所有字符
a='1233'
b='1' in a
b='1' not in a
a='1\t2'#1 2
a=r'1\t2'#1\t2
a=R'1\t2'#1\t2
b=u'a\u5343bcd' #定义一个 Unicode 字符串 a千bcd
c='ab'
d=c.capitalize()#Ab
a="123"
b=a.center(6)#( 123 )
b=a.count('1',0,2)
a='123'
b=a.encode('UTF-8','strict')#编码
c=b.decode('UTF-8','strict')#解码，'ignore' 或 者'replace'
a='123'
b=a.endswith('3',0,3)#true
string.startswith(obj, beg=0,end=len(string))
a='1\t2\t3'
b=a.expandtabs(8)#1 2 3将/t转为空格
a='123'
b=a.find('2',0,3)
c=a.index('2',0,3)#如果不在会报异常
string.rfind(str, beg=0,end=len(string) )#类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))#类似于 index()，不过是从右边开始.
string="123"
string.isalnum()#如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()#如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal()#如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()#如果 string 只包含数字则返回 True 否则返回 False.
string.islower()#如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()#如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()#如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()#如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()#如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
a=('1','2','3')
string="|"
b=string.join(a)#1|2|3
a='123'
b=a.maketrans('1','a')#创建转换表，{49: 97}
string.translate(str, del="")#根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
a='12345'
b=a.partition("2")#('1', '2', '345')
string.rpartition(str)#类似于 partition()函数,不过是从右边开始查找
a='12345'
b=a.replace('2','a',1)
a="1234"
b=a.split("3",4)#['12', '4']
string.splitlines([keepends])#('\r（回车符）', '\r\n', \n(换行符)')分隔,返回列表，keepends=false不包含\n
string.lower()#转换 string 中所有大写字符为小写.
string.swapcase()#翻转 string 中的大小写
string.title()#所有单词都是以大写开始
string.rstrip()#删除 string 字符串末尾的空格.
string.lstrip()#截掉 string 左边的空格
string.strip([obj])#在 string 上执行 lstrip()和 rstrip()
string.ljust(width)#返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.rjust(width)#返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
max(str)#返回字符串 str 中最大的字母。
min(str)#返回字符串 str 中最小的字母。
格式化，只是针对int,float,string三种类型的数据。方法两种，一种是“%？？”%？？；另一种是“{:??}”.forment()。
格式化：
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
格式化-方法1-利用%
int：#总结就是%0.-N*+
除了%d，还有%uoxXeEp还有其他
num = +14
#如果num是个负数，那么这个-，也算做一位。
#如果num=+14，显示结果自动消掉+，要想最后显示有+，需要在%后加+
# %d打印时结果是14
print("num=%d" % num ) # output: num=14
# %1d意思是打印结果为1位整数，当整数的位数超过1位时，按整数原值打印，所以%1d的打印结果还是14
print("num=%1d" % num ) # output: num=14
# %3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数左侧补空格，所以%3d的打印结果是 14
#d前面加N，如果N比数据的长度大，则数据前面补空格，如果N前面有0，则补0；如果N比数据长度小，则无作用。
print("num=%3d" % num ) # output: num= 14
# %-3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数右侧补空格，所以%3d的打印结果是14_
print("num=%-3d" % num) # output: num=14_
# %05d意思是打印结果为5位整数，当整数的位数不够5位时，在整数左侧补0，所以%05d的打印结果是00014
print("num=%05d" % num) # output: num=00014
#加0可以在左侧补0，加.同样可以在左侧补0，但是加.的时候算位数，负号不算
# %.3d小数点后面的3意思是打印结果为3位整数，
# 当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果是014
print("num=%.3d" % num) # output: num=014
# %.0003d小数点后面的0003和3一样，都表示3，意思是打印结果为3位整数，
# 当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果还是014
print("num=%.0003d" % num ) # output: num=014
# %5.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，再在左侧补空格，
# 规则就是补0优先，最终的长度选数值较大的那个，所以%5.3d的打印结果还是 014
print("num=%5.3d" % num ) # output: num= 014
# %05.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，
# 由于是05，再在左侧补0，最终的长度选数值较大的那个，所以%05.3d的打印结果还是00014
print("num=%05.3d" % num ) # output: num=00014
# 还可以用%*.*d来表示精度，两个*的值分别在后面小括号的前两位数值指定
# 如下，不过这种方式04就失去补0的功能，只能补空格，只有小数点后面的3才能补0
print("num=%*.*d" % (5, 3, num) ) # output: num= 014
float:
#小数点也算1位
import math
# %f, 表示原值，默认是小数点后5位数
print("PI=%f" % math.pi) # output: PI=3.141593
# %af，表示打印长度9位数，小数点也占一位，不够左侧补空格
print("PI=%9f" % math.pi) # output: PI=_3.141593
# %a.f，表示去掉小数输出整数，03表示不够3位数左侧补0
print("PI=%03.f" % math.pi) # output: PI=003
# %.bf,长度不管，小数保留2位
print("PI=%.2f" % math.pi) # output: PI=3.14
# %a.bf, %6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够左侧补空格
print("PI=%6.3f" % math.pi) # output: PI=_3.142
# -改成右侧补空，%-6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够右侧补空格
print("PI=%-6.3f" % math.pi) # output: PI=3.142_
# %*.*f，还可以用%*.*f来表示精度，两个*的值分别在后面小括号的前两位数值指定，不过失去补0的功能，只能补空格
print("PI=%*.*f" % (6, 3, math.pi)) # output: PI=_3.142string:
string = "hello"
#%s,打印时结果是hello
print("%s"%string) # output:hello
#%2s,意思是字符串长度为2，当原字符串的长度超过2时，按原长度打印，所以%2s的打印结果还是hello
print("%2s"%string) # output:hello
#%7s,意思是字符串长度为7，当原字符串的长度小于7时，在原字符串左侧补空格，
# 所以%7s的打印结果是 hello
print("%7s"%string) # output: hello
#%-7s,意思是字符串长度为7，当原字符串的长度小于7时，在原字符串右侧补空格，
# 所以%-7s的打印结果是 hello
print("%-7s!"%string) # output:hello !
#%.2s截取，意思是截取字符串的前2个字符，所以%.2s的打印结果是he，当原字符串长度小于2时，即是字符串本身
print("%.2s"%string) # output:he
#%a.bs，先截取，后补空格。这种格式是上面两种格式的综合，首先根据小数点后面的数b截取字符串，当截取的字符串长度小于a时，还需要在其左侧补空格
print("%7.2s"%string) # output: he
print("%2.7s"%string) # output:hello
print("%10.7s"%string) # output: hello
# 还可以用%*.*s来表示精度，两个*的值分别在后面小括号的前两位数值指定
print("%*.*s"%(7, 2, string)) # output: he
字符串格式化-方法2-利用format
int:
#左侧补0
print("{:0>2d}".format(5)) #05 #数字补零 (填充左边, 宽度为2)
#右侧补x
print("{:x<4d}".format(5))#5xxx #数字补x (填充右边, 宽度为4)
#加，分隔
print("{:,}".format(1000000))#1,000,000 #以逗号分隔的数字格式
#左侧补空格
print("{:10d}".format(13))
#右侧补空格
print("{:<10d}".format(13))
#左右补空格，数据居中
print("{:^10d}".format(13))#13 #中间对齐 (宽度为10)数字其他格式:
print("{:.2%}".format(0.25))#25.00% #百分比格式
print("{:.2e}".format(1000000000))#1.00e+09 #指数记法
print('{:b}'.format(11))#1011
print('{:d}'.format(11))#11
print('{:o}'.format(11))#13
print('{:x}'.format(11))#b
print('{:#x}'.format(11))#0xb
print('{:#X}'.format(11))#0xBfloat:
#:.bf, 保留小数位， 没有:a.f 和 :af的格式
print("{:.2f}".format(3.1415926))#3.14 保留小数点后两位
#:+,如果是负数，则+失去用处，如果是负数，则在结果前加+符号
print("{:+.2f}".format(3.1415926))#+3.14 带符号保留小数点后两位
print("{:+.2f}".format(-1)) #-1.00 带符号保留小数点后两位
string:单纯就是替换内容
#format(string1,string2)
print("{1} {0} {1}".format("hello", "world"))
#format(str1=string1,str2=string2)
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# format(字典)
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
# format(列表)
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
#format(对象)
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
（值不可变）3-Tuple（元组）-序列
t1 = ('abcd', 786, 20, 'runoob', 70.2)
t = 12345, 54321, 'hello!'
u = t, (1, 2, 3, 4, 5)#((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
t2=(t1, 3)
t3 = () # 空元组
t33=tuple()
t4 = (20,) # 一个元素，需要在元素后添加逗号
#tup1[2]=3 错误，不能修改
del t3,t2
t5=t1[2:3]#(20,)
#r1= cmp(t4, t5) #python3.X没有了
import operator
r1=operator.eq(t4,t5)
r2=len(t5)
r3=max(t5)
r4=min(t5)4-List(列表) -序列
（值可变）
l1 = ['abcd', 786, 2.23, 'runoob', 70.2]
l1[2:3]=[32, 2.2]#赋值
l5=l1[2:4];l6=l1[3];l1[-1];l1[1:]#取值
l2=[l1, 1]
l3=l2*2
l4=l1+l2
l7 = [] ## 空列表
l77=list()
l7.append('Google') ## 使用 append() 添加元素
l7.append('Runoob')
max(l7)
min(l7)
del l7[1]
len(l7)
for x in l7:
print(x)
list.count(l7,'baidu')
list.extend(l7,l1)
list.index(l7,'Google')
list.insert(l7,0,'baidu')
rr1=list.pop(l7)#弹出末尾值
list.remove(l7,'abcd')
list.reverse(l7)
ll1=[2,1];list.sort(ll1)
遍历：
for i, list in enumerate(lists):
5-Dictionary(字典) -映射
（可变）
#字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型(数字，字符串或元组可以,列表不行)，且唯一。
d1={'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
d11=dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
d111=dict(Runoob=1, Google=2, Taobao=3)
d1['name']='haha'
d1[1]='heihei'#1是键，而非序号
d2 = {}
d22=dict()
del d1['name']
d11.clear()
dict.clear(d11)
del d11
print(d1.keys()) # 输出所有键
print(d1.values()) # 输出所有值
dict4={x: x ** 2 for x in (2, 4, 6)}#{2: 4, 4: 16, 6: 36}
len(d111)
type(d111)
d112=dict.copy(d111)
t1=('Google','Taobao')
d113=d112.fromkeys(t1,1)#值全部为1
d3=d1.get('name')
#d4=d1.has_key('name') python3没有
l1=d1.items()#返回dict_items
value5=d1.pop('code')#根据键，返回值
d1.setdefault('a')#如果键不存在于字典中，将会添加键并将值设为None
d1.update(d2)#d2更新到d1
6-Set(集合)-集合
s1 = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
s11 = set('Tom')#只能有一个参数，可以是一个字符串
s12=set([1,2,3]) #也可以是一个列表
s2=set()
if 'Rose' in s1 :
print('here')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
格式转换
1-string | list->tuple
a="12345"
b=tuple(a)
print(b)#('1', '2', '3', '4', '5')
a=['1',2]
b=tuple(a)
print(b)#('1', 2)
2-string | tuple->list
a="12345"
b=list(a)
print(b)#['1', '2', '3', '4', '5']
a=('1',2)
b=list(a)
print(b)#['1', 2]
3-list|tuple|string->set
list=[1,2]
tuple=(3,4)
string="56"
set=set(list)#{1, 2}
set=set(tuple)#{3, 4}
set=set(string)#{'6', '5'}
4-list|tuple|string->frozenset
list=[1,2]
tuple=(3,4)
string="56"
set=frozenset(list)#frozenset({1, 2})
set=frozenset(tuple)#frozenset{3, 4})
set=frozenset(string)#frozenset{'6', '5'})
5-string->ASCII
string0="a"
r=ord(string0)#97
5-1ASCII->string
a=97
b=chr(a)#a
6-int->HEX
num=20
string1=hex(num)
7-int->OCT
string2=oct(num)
8-int<->float
a=int(3.6) #3
c=float(7)
9-string->int
a=int()#0
a=int('12',16)
a=int('0xa',16)
a=int('10',8)
10-string|int->float
a=float('12')
b=float(13)
11-序列->list
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a=list(enumerate(seasons))#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
12-十进制->十六进制
a=hex(12345)#0x3039
13-十进制->八进制
a=oct(12345)#0o30071
14-字符->ASCII
a=ord('a')#97
15-十进制->二进制
bin()
16-int->bool
bool()
17-数字->ACSII
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
unichr和 chr()函数功能基本一样， 只不过是返回 unicode 的字符。将ASCII转字符
18-对象->字符串
repr() 函数将对象转化为供解释器读取的形式。
str()转化成人阅读的形式
19-
运算符
'''
算术运算：+-*/% // **
比较运算：== != <> > < >= <=
赋值运算：= += /= *= %= **= //=
位运算：& | ^ ~ << >> (result is 0b?????)
逻辑运算：and or not (result is 1 or 0)
成员运算符： in ,not in #a in list
身份运算符：is ,is not
'''
a=10;b=20;a and b# =1
a=0;b=20;a and b# =0
a=10;b=11;a & b #=10000 & 10001=10000=10
'''
优先级：
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 'AND'
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not and or 逻辑运算符
'''
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
