1.长整型

python3中没有长整型的概念；

python2中, num=2L type(num) => ‘long’

1. 复数

x=1-2j
print(x.real)    #取实部
print(x.imag)    #取虚部

1.0

-2.0

1. 字符串_需要掌握的操作

#1. strip, lstrip, rstrip      #作用于首尾两端，可连用，不改变原字符串

name = '*egon**'
   print(name.strip('*'))
   print(name.lstrip('*'))
   print(name.rstrip('*'))

egon

egon**

*egon

#2. lower, upper

name='eGon'
   print(name.lower())
   print(name.upper())

egon

EGON

#3. startswith, endswith  #判断

name='alex_AB'
    print(name.endswith('ab'))
    print(name.startswith('alex'))

False

True

#4. format的三种玩法

也可用%(s), 但%s不只针对字符串；format后元素数量可多余前面，%s必须前后对应，否则报错。

res0 = ‘%s%s%s’%(‘egon’,18,’male’)

res1 ='{}{}{}'.format('egon',18,'male')  #{}为字符串的占位符
    res2='{1}{0}{1}{1}{1}'.format('egon',18,'male') #{}中可放数字
    res3='{name}{age}{sex}'.format(sex='male',name='egon',age=18) #{} 不依赖于顺序
    print(res1,res2,res3)

egon18male 18egon181818 egon18male

#5. split, rsplit  #默认分隔符是空格, 默认 max_split为-1(全分割)

name='root:x:0:0::/root:/bin/bash'
   print(name.split(':'))  
   name='C:/a/b/c/d.txt'
   print(name.split('/',2))               ## 等于1时可拿到顶级目录
   name='a|b|c'
   print(name.rsplit('|',1))

name.rsplit('|')  ==  name.split('|') ## 默认 max_split为-1

['root', 'x', '0', '0', '', '/root', '/bin/bash']     ##注意：：的输出结果

['C:', 'a', 'b/c/d.txt']

['a|b', 'c']

#6 **join    ##可迭代对象必须是字符串

join与split对应，join 传入的列表必须只包含字符串类型

‘ ’.join()  # ‘‘=》以什么连接 （）=》只包含字符串的列表

tag=''
   print(tag.join(['egon','say','hello','world']))

egonsayhelloworld

‘’.join[1,2,3] =》报错

#7 replace   #默认全部替换

name='alex say: i have one tesla, my name is alex'

print(name.replace('alex','AB',3))

AB say: i have one tesla, my name is AB

*看到参数self，当不存在

#8 isdigit  #可判断bytes和unicode类型，是最常用的用于判断字符是否为“数字”的方法；只判断bytes，unicode类型的整数字符串为真

age=input('>>: ')
   print(age.isdigit())

True or False

age = 10
   inp = input('>>: ').strip()
   if inp.isdigit():
       inp = int(inp)
       if inp > age:
           print('too big')
   else:
       print('输入非法数据')

1. 字符串的其他操作（了解）

#1. find, rfind, index, rindex, count

name='egon say hello'
    print(name.find('o',1,3)) #顾头不顾尾，找到显示sub集的起始位置的索引, 不指定范围找第一个，找不到则返回-1不会报错

print(name.index('e',2,4)) #类似find，但找不到报错
    print(name.count('e',1,3)) #顾头不顾尾，不指定范围查找所有

2

Traceback (most recent call last):

0

#2. center, ljust, rjust, zfill

name='egon'
    print(name.center(30,'-'))
    print(name.ljust(30,'*'))
    print(name.rjust(30,'*'))
    print(name.zfill(50))   #用0填充，默认右对齐

-------------egon-------------

egon**************************

**************************egon

0000000000000000000000000000000000000000000000egon

#3. expandtabs

name='egon\thello'
    print(name)
    print('\t')
    print(name.expandtabs(0))  #参数为tabsize，指空格数
    print(name.expandtabs(1))

egon hello

egonhello

egon hello

\t =》 表tab，本质是空格，不同平台默认的空格数不一致

\n =》 表换行

#4. captalize, swapcase, title

msg='egon sAy hi'
    print(msg.capitalize())  #首字母大写
    print(msg.swapcase())    #大小写翻转
    print(msg.title())       #单个单词的首字母大写

Egon say hi

EGON SaY HI

Egon Say Hi

#5. is数字类型

is数字类型是用来判断字符串的，字符串中数字有四种类型

*num1=b ‘4’ # bytes 字节

*num2=u ‘4’《=》‘4’ # unicode, python3中无需加u就是unicode

num3=‘四’ #中文数字

num4= ‘IV’#罗马数字

对isdigit： 1 True， 2 True， 3 False， 4 False  #判断bytes和unicode的阿拉伯整数为真（数字）；是最为常用的is数字类型

对isdecimal: 1无， 2 True， 3 False， 4 False  #只能判断unicode格式的阿拉伯整数为真（数字）

对 isnumeric：1无， 2 True， 3 True， 4 True  # 能判断unicode，中文数字， 罗马数字格式的阿拉伯整数为真（数字）；可能会用到银行项目

#6. is 其他

print(name.isalpha())  #字符串只有字母组成
    print(name.isalnum())  #字符串有字母或数字组成
    print(name.isidentifier())
    print(name.islower())
    print(name.isupper())
    print(name.isspace())
    print(name.istitle())

1. 字符串的总结

存放一个值；有序（序列类型，能按照索引取值），不可变

#‘序列类型’不是一种类型，为方便理解

list有序， dict无序（不能按照索引取值）

1. 列表的基本使用

定义：中括号内可以有多个任意类型的值，逗号分隔

l2=list('hello')
    print(l2)
    l3=list(111)
    print(l3)

['h', 'e', 'l', 'l', 'o']       #相当于for循环

Traceback (most recent call last):   #报错

1. 列表优先掌握定的操作

#1 按索引存取值（正向存取+反向存取）；即可存也可取

l=['a','b','c']
     print(l,id(l))
     l[0]='A'
     print(l,id(l))

['a', 'b', 'c'] 4367353032

['A', 'b', 'c'] 4367353032   #列表为可变类型，id不变， 不可通过索引加值，否则报错

#2 切片（顾头不顾尾，步长）

stus = ['alex','egon','wxx','yxx', 'lxx']
     print(stus[1:3])

['egon', 'wxx']  #所取值依旧为列表

#3 长度

stus = ['alex','egon','wxx','yxx', 'lxx']
     print(len(stus))

5   #列表中元素的个数

#4 成员运算in和not in

#5 追加

stus = ['alex','egon','wxx','yxx', 'lxx']
     print(stus.append('ab'))  #往后加值,一次加一个值
     print(stus)

None

['alex', 'egon', 'wxx', 'yxx', 'lxx', 'ab']

插入：

stus = ['alex','egon','wxx','yxx', 'lxx']
    print(stus.insert(1, 'ab'))  #1为起始位置，insert一次加一个值
    print(stus)

None

['alex', 'ab', 'egon', 'wxx', 'yxx', 'lxx']

#6 删除

del stus[1]  #万能删除，不止针对列表

stus = ['alex','egon','wxx','yxx', 'lxx']
    print(stus.remove('alex'))   #remove只能按照成员删，按索引报错
    print(stus)
    print(stus.pop(1)) #按索引删，若不加参数，默认删掉末尾（默认参数为-1）
    print(stus)

None    #用remove删是单纯的删除，没有返回值

['egon', 'wxx', 'yxx', 'lxx']

wxx     #用remove删，是取走/弹出一个值

['egon', 'yxx', 'lxx']

#7 循环

1. 依赖索引

i=0
stus = ['alex','egon','wxx','yxx', 'lxx']
while i <len(stus):
    print(stus[i])

i+=1

for i in range(len(stus)):
           print(i,stus[i])

1. 不依赖索引

stus = ['alex','egon','wxx','yxx', 'lxx']
for item in stus:
    print(item)

1. 补充for循环

  for i in range(1,5,2): #(起始，结束，步长)，顾头不顾尾
      print(i) # 1 3

  for i in range(10):  #一个参数时，10默认是结束位置，起始位置默认为0
      print(i)     #0 1 2 …9

for i in range(10,-2,-1):
          print(i)      #10 9 8 …-1

stus=['alex','egon','wxx','yxx']
      for i in range(len(stus)):

print(i,stus[i])

0 alex

1 egon

2 wxx

3 yxx

for循环中，break和continue依旧适用， 有for else用法

1. 列表需要掌握的操作

#1

stus=['alex','egon','wxx','yxx']
    print(stus.clear())  #清空
    print(stus)

None

[]

#2

stus=['alex','egon','wxx','yxx']
    print(stus.copy())  #拷贝
    print(stus)

['alex', 'egon', 'wxx', 'yxx']

['alex', 'egon', 'wxx', 'yxx']

#3

stus=['alex','egon','wxx','yxx']
    print(stus.count('e'))  #统计元素数量
    print(stus)

0

['alex', 'egon', 'wxx', 'yxx']

#4

stus=['alex','egon','wxx','yxx'] 
   print(stus.extend('alex'))  #extend 可加多个值
   print(stus)

None

['alex', 'egon', 'wxx', 'yxx', 'a', 'l', 'e', 'x']

#5

stus=['alex','egon','wxx','yxx']
  print(stus.index('yxx',0,4))  #取元素的索引
  print(stus)

3

['alex', 'egon', 'wxx', 'yxx']

#6

stus=['alex','egon','wxx','yxx']
   print(stus.reverse())  #元素反写
   print(stus)

None

['yxx', 'wxx', 'egon', 'alex']

#7

stus=['alex','egon','wxx','yxx']
    print(stus.sort(reverse =True))  #正（反）向排序
    print(stus)

None

['yxx', 'wxx', 'egon', 'alex']

注： __xx__ 为python的内置方法，当输入满足时，自动出现，不需调用

e.g.: print(len(stus))  # print(stus.__len__())

sort只针对纯数字或纯字母 [1,10, ‘a’].sort() 报错

字符串的比较是从第一个字符开始一个一个比较，且必须同时比较的两者属于一个类型（数字/字母），否则报错。A Z a z 从小到大

1. 队列（先进先出）

入队： l1.append(‘first’) ; l1.append(‘second’); l1.append(‘third’)

出队： l1.pop(0); l1.pop(0); l1.pop(0)

#思考用insert怎么实现

1. 堆栈（先进后出，后进先出）

入栈：l1.append(‘first’) ; l1.append(‘second’); l1.append(‘third’)

出栈：l1.pop(); l1.pop(); l1.pop()

1. 列表总结

可以存多个值，有序，可变