【笔记】Python基础一 ：变量，控制结构，运算符及数据类型之数字，字符串，列表，元组，字典

一，开发语言介绍

    高级语言：Java，C#，Python  ==》产生字节码

    低级语言：C，汇编                   ==》产生机器码

    高级语言开发效率高，低级语言运行效率高

    Python种类：
    JPython
    IronPython
    JavaScriptPython
    RubyPython
    CPython **********
    pypy 这是用CPython开发的Python

二，Python文件执行的条件

1，解释器指定

    Windows系统中

        D:\python35\python 2.py

    Linux系统中

        如果使用./2.py则在文件内部需要指定Python解释器

        #!/usr/bin/python 或者 #!/usr/bin/python2.7

并给执行权限

chmod 755 2.py

 

2，字符编码指定

    # -*- coding:utf8 -*-

    只对python2有效，python2默认使用ASC码对照表解释

    ascill 00000000

    & 00000001

    unicode 0000000000000000+

    & 0000000000000001
    中 001000000000000111110010

    utf-8 能用多少表示就是用多少表示，表示汉字用3字节
    & 00000001
    中 001000000000000111110010

    gbk使用2个字节

   

三，Python基础

（一）变量
变量作用是记录状态

1，变量名
- 字母
- 数字
- 下划线
PS：
数字不能开头
不能是关键字
最好不要和python内置的东西重复 ***

name = "石正文"

 2，变量基本类型

字符串

数字

列表

元组

字典

3，可变不可变

1），可变：修改变量的值，id值不变。列表，字典

2），不可变：新建立变量后需要开辟新内存地址。字符串，数字，元组

4，访问顺序

1），顺序（序列对象）：字符串，列表，元组

2），映射：字典

3），直接：数字

5，存放元素个数

容器类型：列表，元组，字典

原子：数字，字符串

（二）控制结构
1. 条件语句：缩进用4个空格
a.
n1 = input('>>>')

if "alex" == "alex":
　　n2 = input('>>>')
        if n2 == "确认":
　　　　print('alex SB')
　　else:
　　　　print('alex DB')
else:
　　print('error')

注意：
n1 = "alex" 赋值
n1 == 'alex' 比较，

b.
if 条件1：
　　pass
elif 条件2:
　　pass
elif 条件3:
　　pass
else:
　　pass
print('end')

c. 条件1
and or

if n1 == "alex" or n2 == "alex!23":
　　print('OK')
else:
　　print('OK')

PS:
pass 代指空代码，无意义，仅仅用于表示代码块

 

2.while循环语句

while 条件：
....
print('...')

补充：
a. while else
b. continue break
    continue ,终止当前循环，开始下一次循环
    break ,终止所有循环

count = 0
s = 0

while count < 10:
    if count != 7:
        print (count)
    count = count + 1
print('----end----')

count = 1
while count < 101:
    s = count + s
    count = count +1
print(s)
print('----end----')

count = 1
while count < 101:
    if count%2 == 1:
        print(count)
    else:
        pass
    count = count + 1

print('----end----')

count = 1
while count < 101:
    if count%2 == 0:
        print(count)
    else:
        pass
    count = count + 1

print('----end----')

count = 1
s = 0
while count < 101:
    if count%2 == 0:
        s = s - count
    else:
        s = s + count
    count = count + 1
print(s)
print('----end----')

　　

（三）运算符
结果是值
    算数运算
    a = 10 * 10
    赋值运算
    a = a + 1 a+=1

结果是布尔值
    比较运算
    a = 1 > 5
    逻辑运算
    a = 1>6 or 1==1
    成员运算
    a = "蚊" in "郑建文"

（四）基本数据类型

字符串 - n1 = "alex" n2 = 'root' n3 = """eric""" n4='''tony'''
数字 - age=21 weight = 64 fight = 5

数字：
n1 = 9
n2 = 2

n3 = n1 + n2
n3 = n1 - n2
n3 = n1 * n2
n3 = n1 / n2
n3 = n1 % n2
n3 = n1 ** n2

 

数字 int ，所有的功能，都放在int里
a1 = 123
a1 = 456

- int
将字符串转换为数字
a = "123"
print(type(a),a)

 

b = int(a)
print(type(b),b)

num = "0011"
v = int(num, base=16)
print(v)

- bit_lenght
# 当前数字的二进制，至少用n位表示
r = age.bit_length()

 

num = 12
n = num % 2
if n == 0:
　　print('偶数')
else:
　　print('奇数')


字符串：
加法：
n1 = "alex"
n2 = "sb"
n4 = "db"
n3 = n1 + n2 + n4
# "alexsbdb"

乘法：
n1 = "alex"
n3 = n1 * 10

字符串 str
s1 = "asdf"
s2 = "asdffas"

 

字符串的魔法

小技巧：输入关键字，使用CTRL加鼠标左键单击，跳转到源码，进一步就可以看到方法的声明，然后学习相应的方法。（适用于所有的语言）

#首字母大写
test = "aLex"
v = test.capitalize()
print(v)

 
# 所有变小写，casefold更牛逼，很多未知的对相应变小写
v1 = test.casefold()
print(v1)
v2 = test.lower()
print(v2)


# 设置宽度，并将内容居中
# 20 代指总长度
# * 空白未知填充，一个字符，可有可无
v = test.center(20,"中")
print(v)

# 左右对齐
test = "alex"
v = test.ljust(10,"*")
print(v)
v = test.rjust(10,"_")
print(v)
v = test.zfill(10)
print(v)

# 去字符串中寻找，寻找子序列的出现次数
test = "aLexalexr"
v = test.count('ex')
print(v)

test = "aLexalexr"
v = test.count('ex',5,6)
print(v)

 

# 欠
# encode
# decode

 

# 以什么什么结尾
# 以什么什么开始
test = "alex"
v = test.endswith('ex')
v = test.startswith('ex')
print(v)

 

# 以expandtabs里的数字为一组，使用\t补全该组
test = "12345678\t9"
test1 = "username\temail\tpassword\nlaiying\tying@email.com\t123"
v = test.expandtabs(6)
v1 = test1.expandtabs(20)
print(v,len(v))
print(v1)

 

# 从开始往后找，找到第一个之后，获取其位置
# > 或 >=
test = "alexalex"
# 未找到 -1
v = test.find('ex')
print(v)

 

# index找不到，报错 忽略
test = "alexalex"
v = test.index('8')
print(v)


# 格式化，将一个字符串中的占位符替换为指定的值
test = 'i am {name}, age {a}'
print(test)
v = test.format(name='alex',a=19)
print(v)

test = 'i am {0}, age {1}'
print(test)
v = test.format('alex',19)
print(v)


# 格式化，传入的值 {"name": 'alex', "a": 19}
test = 'i am {name}, age {a}'
v1 = test.format(name='df',a=10)
v2 = test.format_map({"name": 'alex', "a": 19})

 

# 字符串中是否只包含 字母和数字
test = "123"
v = test.isalnum()
print(v)

 

#是否包含字母，汉字
test = "asdf2"
v = test.isalpha()
print(v)


#是否是数字,isdecimal十进制-》isdigit包含特殊字符数字①-》isnumeric能识别大写的“二”
test ="①"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3)


# 符合标识符规则就行，不能以数字开头
test ="class"
v = test.isidentifier()
print(v)


#是否存在不可显示的字符\t \n
test ="ssn\tdd"
v = test.isprintable()
print(v)

#判断是否全部是空格
test =" "
v = test.isspace()
print(v)

#每个词的首字母都大写，成为标题
test = "A is For Anna"
v =  test.istitle()
print(v)
v2 = test.title()
print(v2)
v3 = v2.istitle()
print(v3)


#*****字符串的每一个字符使用指定分隔符进行拼接
test ="你是风儿我是沙"
print(test)
t =' '
v = t.join(test)
print(v)

 

#判断是否全部是大小写，转换成大小写
test = "Alex"
v1 = test.islower()
v2 = test.lower()
print(v1,v2)

v1 = test.isupper()
v2 = test.upper()
print(v1,v2)

#去除空格及不可见字符\t \n,指定内容可以把指定内容去掉，有限最多匹配
test = "\nalex "
print(test)
v = test.lstrip()
print(v)
v = test.rstrip()
print(v)

test = "xalex "
print(test)
v = test.lstrip(‘9lexex’)
print(v)


# 对应替换
test = "你是风儿我是沙"
test1 = "去你妈的风河沙"
v = "你是风儿我是沙 334"
m = str.maketrans(test,test1)
new_v = v.translate(m)
print(new_v)


# 如果能分割，分割成三份
test = "testasdsddfg"
v = test.partition('s')
print(v)
v = test.rpartition('s')
print(v)
# 全部分割，或者指定分割次数，但取不到分隔符
v = test.split('s',2)
print(v)
v = test.rsplit('s',2)
print(v)

#只能根据换行分割，True,False用来指定保留换行符\n
test = "asdfasdf\nasdfasdf\nasdf"
v = test.splitlines(True)
print(v)


#以X开头，以X结尾
test = "backend 1.1.1.1"
v = test.startswith('B')
print(v)
v = test.endswith('1')
print(v)

#大小写转换
test = "aLEx"
v = test.swapcase()
print(v)

#将指定字符串替换为指定字符串
test = "alexalexalex"
v = test.replace("ex",'bbb')
print(v)
v = test.replace("ex",'bbb',2)
print(v)

公共子序列

“alex”和“uilex”的公共子序列是“lex”

 

###################### 7个基本魔法 ######################
# join # '_'.join("asdfasdf")    可以用于其它数据类型
# split
# find
# strip
# upper
# lower
# replace

###################### 5个灰魔法 #####################

test = "郑建文妹子有种冲我来"

# 一、for循# for 变量名 in 字符串:

#     变量名
# break
# continue
                                            
index = 0
while index < len(test):
    v = test[index]
    print(v)
        index += 1

print('=======')

for zjw in test:
    print(zjw)

test = "郑建文妹子有种冲我来"
for item in test:
    print(item)
    break

for item in test:
    continue
    print(item)


# 二、索引，下标，获取字符串中的某一个字符
v = test[3]
print(v)

# 三、切片
v = test[0:-1] # 0=<  <1
print(v)

# 四、获取长度
# Python3： len获取当前字符串中由几个字符组成
v = len(test)
print(v)

#计算列表里面元素个数
li = [11,22,33,44,55]
len(li)


# 注意：在其他数据类型中下面这些操作一样可以用
# len("asdf")
# for循环
# 索引
# 切片

# 五、range()获取连续或不连续的数字，
# Python2中直接创建在内容中
# python3中只有for循环时，才一个一个创建
# r1 = range(10)
# r2 = range(1,10)
# r3 = range(1,10,2)
# 帮助创建连续的数字,通过设置步长来指定不连续
# v = range(0, 100, 5)
#
# for item in v:
#     print(item)

 

# 练习题：根据用户输入的值，输出每一个字符以及当前字符所在的索引位置 
test = input(">>>")
for item in test:
     print(item)

# 将文字 对应的索引打印出来：
test = input(">>>")
print(test)   # test = qwe   test[0]   test[1]
l = len(test) # l = 3
print(l)

r = range(0,l) # 0,3
for item in r:
     print(item, test[item]) # 0 q,1 w,2 e

test = input(">>>")
for item in range(0, len(test)):
     print(item, test[item])

###################### 1个深灰魔法 ######################

# 字符串一旦创建，不可修改
# 一旦修改或者拼接，都会造成重新生成字符串

name = "zhengjianwen"
age = "18"

info = name + age
print(info)

 做练习题补漏

#1，在切片里面，-1代表最后一个位置，因此下面输出rooted。-2代表倒数第二个位置
name = "rootedd"
print(name[1:-1])

#2，只要一个对象能执行 
for  i  in 值
    print(i)
就可以称为可迭代对象

#3，类，类型
str 是一个类型，bool是一个类型
a1 = “alex”  a1是一个对象

#4，range用法
#在python2还有一个xrange()，相当于python3里面的range，for循环的时候才一个一个创建。

#从100 到0，注意步长为-1
for i in range (100,0,-1):
    print(i)

#5，Pycharm 有reformat代码的功能

列表 list

 ###################### 魔法，list类中提供的方法 ######################

#1,原来值后追加
li = [11,22,33,44]
v = li.append(5)
print(v)
print(li)
li.append([1234,5678])
print(li)

#2，清空列表
li.clear()
print(li)

#3,浅拷贝
li = [11,22,33,"123","alex"]
v = li.copy()
print(v)

#4，计算元素出现的次数
v = li.count("123")
print(v)

#5, 扩展原来的列表，参数是可迭代对象，与append区别是，append把参数当成整体添加，extend则拆解添加
li = [11,22,33,22,44]
li.extend([9898,"不得了"])
print(li)
li.extend("下雨了")
print(li)

#6，根据值获取当前值索引位置（左边优先）
li = [11,22,33,22,44]
v = li.index(22,2)
print(v)

#7，在指定索引位置插入
li = [11,22,33,22,44]
li.insert(0,99)
print(li)

#8，删除某个值(可以指定索引，默认是最后一个),并获取删除值
li = [11,22,33,22,44]
v = li.pop(1)
print(li)
print(v)
#删除列表中的指定值，左边优先
li = [11,22,33,22,44]
li.remove(22)
print(li)
#删除方法汇总 1,pop 2,remove 3,del li[0] 4,del li[7:9]  5，clear

#9，将当前列表进行反转
li = [11,22,33,22,44]
li.reverse()
print(li)

#10,列表的排序
li = [11,22,33,22,44]
li.sort(reverse=True)
print(li)
#欠 cmp key sorted


#字符串和列表的区别:字符串创建之后不能修改
v = "alex"
v = v.replace('l','el')
print(v)
#产生新的字符串

li = [11,22,33,44]
li[0]#索引取值
li[0] = 999 #索引修改

s = "alex"
print(s[0]) #索引取值
s[0] = "E"  #索引不能修改
print(s)

 ###################### 深灰魔法######################

#1，列表怎么写：中括号括起来，使用逗号分割，列表中的元素可以是数字,字符串,列表,布尔值,所有的都能放进去，
#2，可以嵌套
#列表的数学抽象就是一个"集合"

li = [1,12,9,"age",["市政",["19",10],"旁买了"],"alex",True]

#3，索引取值
print(li[3])
#嵌套情况取值
print(li[4][1][0])

#4，切片,切片结果也是列表
print(li[3:5])

#5，for,while 循环
# for item in li:
#     print(item)

#6，索引
#索引修改
li[1] = 120
print(li)
li[4] = [11,22,33,44]
print(li)

#索引删除
del li[4]
print(li)

#7，切片
#切片修改
li[0:3] = [1,2,3]
print(li)

#切片删除
li2 = [1,12,9,"age",["市政","旁买了"]]
del li2[2:3]
print(li2)

#8，查找 in操作
li3 = [1,12,9,"age",["市政","旁买了"]]
v = "市政" in li3[4]
print(v)

#9,字符串可以转列表（内部使用for循环），数字不能for循环，不能转换列表
s = "12eewdsd"
new_li = list(s)
print(new_li)
#列表转换成字符串
#如果列表里有字符串和数字的混合，只能使用for循环来转换
li = [11,22,33,"123","alex"]
print(li)
r = str(li)
print(r)

s = ""
for i in li:
    s = s + str(i)
print(s)

#如果列表里只有字符串,则可以使用join简单处理
li = ["123","alex"]
v = "".join(li)
print(v)

元祖 tuple

 ######################  魔法 ######################

#tu.count(22)，获取指定元素在元组中出现的次数
#tu.index(22)，获取某一个值的索引位置

 ###################### 深灰魔法######################

#1,元组是对列表的二次加工，元组的一级元素不可被修改，不能被增加或者删除
#一般写元组的时候，推荐在最后加入逗号
li = [111,22,33,44]
tu =(111,22,33,44,)
#2,索引
v = tu[0]
print(v)
#3,切片
v = tu[0:2]
print(v)

#tu[0] = 123 # 不能修改
#del tu[0] #  不能删除
#4,可以被for循环，可迭代对象（字符串，列表，元组都是可迭代对象）
for item in tu:
    print(item)

#5,转换
s = "asdfasdf0"
li = ['asdf',123]
tu = (123,123,"asdf")

v = tuple(s) #字符串转元组
print(v)

v1 = tuple(li)#列表转元组
print(v1)

v2 = list(tu)#元组转列表
print(v2)

#如果元组里面只有字符串,使用join转换
tu = ("123","asdf")
v = "_".join(tu)
print(v)

#可迭代对象可以使用extend
li = ["asdf","assdfasdf"]
li.extend((11,22,33,))
print(li)

#6，元组也是有序的,元组里面的列表是可以修改的
tu = (111,"alex",(11,22),[(33,44)],True,33,44)
v = tu[3][0][0]
print(v)
#tu[0] = 123
tu[3][0]= 567
print(tu)

字典 dict
######################  魔法 ######################

dt ={}

dt.clear()
dt.copy() #浅拷贝

#静态方法 直接使用类名执行方法
#@staticmethod  # known case
#def fromkeys(*args, **kwargs):  # real signature unknown

#1，根据列表，创建字典，并指定统一值
v = dict.fromkeys(["k1",123,"999"],123)
print(v)

#2，get取值方法
dic = {
    "k1":"v1",
    "k2":"v2"
}
#v = dic['k11111']
#如果键值不存在则报错
#print(v)
#使用get方法就不报错,而返回None,也可以指定返回值
v = dic.get('k111',"asdfasdf")
print(v)


#3，pop方法删除并获取值 ,如果对应键没有，也可以返回设定的返回值
dic = {
    "k1":"v1",
    "k2":"v2"
}
v =  dic.pop("k11",90)
print(v,dic)

#popitem 随机删除
dic = {
    "k1":"v1",
    "k2":"v2"
}
v = dic.popitem()
print(v)

#4，setdefault,如果键存在则不进行设置返回键的原有值；如果键不存在，则添加一个键值对
dic = {
    "k1":"v1",
    "k2":"v2"
}
v = dic.setdefault('k111','123')
print(dic,v)

#5，更新
dic = {
    "k1":"v1",
    "k2":"v2"
}
v = dic.update({'k1':'1111','k3':'222'}) #传值传字典
print(dic)

dic.update(k1=123,k2=345,k3=456) #如果在函数中把参数名写成**，则会把参数自动转换成字典
print(dic)

#字典里面最常用的是keys(),values(),items(),get(),update()

 ###################### 深灰魔法######################

#1，字典 dict基本结构
info ={
       "k1":"v1", #键值对
       "k2":"v2"
       }

#2，字典的value可以是任何形式
info ={
    "k1":18,
    "k2":True,
    "k3":[
        11,
        22,
        33,
        {'kk1':'vv1',
         'kk2':'vv2',
         'kk3':(11,22),
         }
     ],
    "k4":(11,22,33,44)
}
print(info)

#3，列表和字典不能作为字典的key
#布尔值可以作为key，但要注意和0，1重复的问题
info = {
    1:'asd',
    "k1":'asdf',
    True:"123",
    #[11,22]:123,
    (11,22):123,
    #{'11':'22'}:123,
}

#4，通过打印可以知道字典是无序的

#5，索引方式(key)找到指定元素
v = info["k1"]
print(v)
v = info[1]
print(v)
info ={
    "k1":18,
    "k2":True,
    "k3":[
        11,
        22,
        33,
        {'kk1':'vv1',
         'kk2':'vv2',
         'kk3':(11,22),
         }
     ],
    "k4":(11,22,33,44)
}
#找到kk3里面的的11
v = info["k3"][3]["kk3"][0]
print(v)
#字典不能通过切片方式找

#6，del删除
info ={
    "k1":18,
    "k2":True,
    "k3":[
        11,
        22,
        33,
        {'kk1':'vv1',
         'kk2':'vv2',
         'kk3':(11,22),
         }
     ],
    "k4":(11,22,33,44)
}
print(info)
del info["k1"]
print(info)
del info["k3"][3]["kk1"]
print(info)


#7，字典支持for循环
info ={
    "k1":18,
    "k2":True,
    "k3":[
        11,
        22,
        33,
        {'kk1':'vv1',
         'kk2':'vv2',
         'kk3':(11,22),
         }
     ],
    "k4":(11,22,33,44)
}

for item in info:
    print(item)

for item in info.keys():
    print(item)

for item in info.values():
    print(item)

for k,v in info.items():
    print(k,v)

布尔值 bool

# 0 1
# bool(...)
# None ""  () []  {} 0 ==> False

#######################　整理 #################

# 一、数字
# int(..)
# 二、字符串
# replace/find/join/strip/startswith/split/upper/lower/format
# tempalte = "i am {name}, age : {age}"
# # v = tempalte.format(name='alex',age=19)
# v = tempalte.format(**{"name": 'alex','age': 19})
# print(v)
# 三、列表
# append、extend、insert
# 索引、切片、循环
# 四、元组
# 忽略
# 索引、切片、循环         以及元素不能被修改
# 五、字典
# get/update/keys/values/items
# for,索引

# dic = {
#     "k1": 'v1'
# }

# v = "k1" in dic
# print(v)

# v = "v1" in dic.values()
# print(v)