基本数据类型

数字类型

• 整型（int）

定义：用来描述/标识类似于人的年龄、手机号码、等级。。。这种状态/特征的

age=21 　　 #age=int(21)
num=13243213   　　 #num=int(13243213)

• 浮点型（float）

定义：用来描述/标识类似于工资、身高、体重。。。这种状态/特征的

salary=2.3 　　 #salary=float(2.3)
width=70.5  　　#width=float(70.5)

字符串及其内置方法

定义方式：加了引号的字符就是字符串类型，在python中并不存在字符类型

用于标识具有描述性的内容

name='lining'   　　#name=str('lining')
address='上海浦东'  　　#address=str('上海浦东')

• 单引号、双引号、多引号的区别

# 单双引号的配合使用方法
msg="it's mine"
info='my name is "lining"'

# 三引号可以实现多行
res='''
白日依山尽，
黄河入海流。
欲穷千里目，
更上一层楼。
'''

• 字符串的运算

# 相加（拼接）
name='李宁，'
say='你好'
print(name+say)     # 李宁，你好
print(name,say)     # 李宁， 你好
# 注意：字符串只能同类型相加，不能与其他类型相加


# 相乘
username='polo'
print(username*5)
# polopolopolopolopolo

• 内置操作方法

# 1、按索引取值(正向取+反向取) ：只能取
msg='hello lining'
print(msg[2:9])        # 范围取值---   llo lin
print(msg[2:9:2])      # 按步长2取值--- loln
print(msg[::-1])       # 列表反转---   gninil olleh
print(msg[-4:])        # 反向取值---   ning

#2、切片(顾头不顾尾，步长)     [x:t:1/-1]
info='name lining age 21'
print(info[0:5])        # 切片范围---   name
print(info[-5:])        # 反向切片---   ge 21
print(info[0:7:2])      # 按步长2切片--- nm i
print(info[:7:-1])      # 按步长-1切片---  12 ega gni

#3、长度len
x='unbelievable'
print(len(x))   # 12

#4、成员运算in和not in
s='python is so good'
print('is' in s)        # True
print('is'not in s)     # False

#5、移除空白strip    # 从左往右在遇到非空白时就停住，然后从右往左移除空白，直到遇到非空白就停住，所以它只能移除两头的空白
str='  * /   that is so good   /     '
print(str.strip())          # 默认空白      * /   that is so good   /
print(str.strip("/ *"))     # 自定义符号     that is so good
print(str.strip(' *'))     # 自定义符号     /   that is so good   /

#6、切分split      按照某个规律将字符串切成一个列表，然后取值
msg='asdqef asfaf asfd'
print(msg.split())     # 默认用空格切分
a='asd:qwe:123:n/:xc'
print(a.split(':'))     # 指定切分符号

#7、循环
msg='hello'
for i in msg:
    print(i)

# h
# e
# l
# l
# o

#1、strip,lstrip,rstrip
msg='    hello guys   '
print(msg.lstrip())     # 只移除左边的空白
print(msg.rstrip())     # 只移除右边的空白
print(msg.strip())      # 移除两边的空白

#2、lower,upper
msg='aASR qTe'
print(msg.lower())
print(msg.upper())

#3、startswith,endswith
res='x is sdan'
print(res.startswith('x'))
print(res.endswith('an'))

#4、format的三种玩法
info1='name is {},age is {}'.format('egon',21)
info2='name is {0},age is {1}'.format('egon',21)
info3='name is {nm},age is {ag}'.format(nm='egon',ag=21)
print(info1)
print(info2)
print(info3)

#5、split,rsplit
str='name:egon:age:12'
print(str.rsplit(':',2))    # 右往左切['name:egon', 'age', '12']
print(str.split(':',2))     # 左往右切['name', 'egon', 'age:12']

#6、join     将列表切回字符串
s='python is so good'
print(s.split())
a=''.join(s)
print(a)

#7、replace
s1='abcdddeefg'
print(s1.replace('d','D',2))    # abcDDdeefg  只替换2个
print(s1.replace('d','D'))    # abcDDDeefg   不写count默认全部替换

#8、isdigit  判断字符串内包含的是否全是数字
ss='1234ds'
print(ss.isdigit())        # True

列表及其内置方法

定义方式：在[]内，用逗号分隔开，可以存取多个值

#取出a
list=[1,3,6,23,'a',[1,]]
print(list[4])

#取出c(嵌套取值)
l=[[1,],[12,'f',['t',]],[3,4,['a','b',['c',]]]]
print(l[2][2][2][0])

• 内置操作方法

#1、按索引存取值(正向存取+反向存取)：即可存也可以取(可以修改列表里的值)
names=['alex','wxx','lxx','egon']
names[0]='ALEX'
print(names)        # ['ALEX', 'wxx', 'lxx', 'egon']

#2、切片(顾头不顾尾，步长)
names=['alex','wxx','lxx','egon']
print(names[0:3])       # ['alex', 'wxx', 'lxx']
print(names[0:4:2])     # ['alex', 'lxx']

#3、长度
names=['alex','wxx','lxx','egon']
print(len(names))       # 4

#4、成员运算in和not in
names=['alex','wxx','lxx','egon',4]
print(4 in names)


#5、追加 append只往最后面添加值
names=['alex','wxx','lxx','egon']
names.append('cxx1')
names.append('cxx2')
print(names)      # ['alex', 'wxx', 'lxx', 'egon', 'cxx1', 'cxx2']
# 5.1、insert可以往列表中间添加值
names=['alex','wxx','lxx','egon',4]
names.insert(1,'SB')
print(names)    # ['alex', 'SB', 'wxx', 'lxx', 'egon', 4]


#6、删除
names=['alex','wxx','lxx','egon']
del names[2]
print(names)        #['alex', 'wxx', 'egon']

names=['alex','wxx','lxx','egon',4,3.1]
res=names.remove('wxx')  # 单纯的删掉,是按照元素的值去删除，返回None
print(res)
print(names)        #['alex', 'lxx', 'egon', 4, 3.1]

names=['alex','wxx','lxx','egon',4,3.1]
res=names.pop(1)    #拿走一个值,是按照索引去删除,有返回值
print(names)
print(res)      # ['alex', 'lxx', 'egon', 4, 3.1]      返回值：wxx

names=['alex','wxx','lxx','egon',4,3.1]     # 拿走一个值,是按照索引去删除,如果不指定索引就会默认从最末尾删除，有返回值
print(names.pop())      # 3.1
print(names.pop())      # 4

#7、循环
names=['alex','wxx','lxx','egon']
for name in names:
    print(name)

• 堆栈与队列

堆栈：其实就是一个后进先出的一个线性表，只能在栈顶压入或弹出元素。用列表表示栈，则向栈中压入元素，可以用列表的append()方法来实现，弹出栈顶元素可以用列表的pop()方法实现。

# 后进先出
l=[]
l.append('a')
l.append('b')
l.append('c')
l.append('d')
print(l)    # ['a','b','c','d']
print(l.pop())  # d
print(l.pop())  # c
print(l.pop())  # b
print(l.pop())  # a

队列：其实就是一个先进先出的线性表，只能在队首执行删除操作，在队尾执行插入操作。用列表表示队列，可以用append()方法实现在队尾插入元素，用pop(0)方法实现在队首删除元素。

# 先进先出
l=[]
l.append('a')
l.append('b')
l.append('c')
l.append('d')
print(l)    # ['a','b','c','d']
print(l.pop(0))  # a
print(l.pop(0))  # b
print(l.pop(0))  # c
print(l.pop(0))  # d

字典

定义方式：在{}内，用key:value的形式，可以存取多个元素，key一般是字符串形式，而value可以是任意类型

dict={'name': 'alex',
      'age' : 21,
      'hometown' : '山东',
      }
print(dict['age'])

#字典嵌套取值
shop_cart={'apple': 21,
           'Dragon fruit' : 13,
           'orange' : 11,
           'supermarket':{
               '橘子':21,
               '圣女果':34
           }
           }
print(shop_cart['supermarket']['橘子'])

# 生成一个新字典
dic=dict(a=1,b=2,c=3)
print(dic)      # {'a': 1, 'b': 2, 'c': 3}

# 将列表信息存成字典格式
userinfo=[
    ['name','lxx'],
    ['age',21],
    ['sex','male']
]
# 方法一：
dic={}
for k,v in userinfo:
    dic[k]=v
print(dic)

# 方法二：
d=dict(userinfo)
print(d)

• 操作及内置方法

# 1、成员运算：判断的是key，而不是value
dic={'name':'egon','age':18,}
print(18 in dic)    # False
print('age' in dic)    # True

# 2、删除（del,pop）
d={'name': 'lxx', 'age': 21, 'sex': 'male'}
# del d['age']
print(d)    # 没有返回值，删除字典不存在的元素时会报错

res=d.pop('name')
print(res)  # lxx   删除key对应的value，并返回value。删除不存在的元素时也会报错
print(d)    # {'age': 21, 'sex': 'male'}

# 3、keys(),values(),items()
dic = {'name': 'jack', 'age': 22, 'sex': 'male'}
for k in dic:
    print(k)
for v in dic.values():
    print(v)
for k, v in dic.items():
    print(k, v)

# 4、将字典转成列表时会将key当做一个个值放进列表中
print(list(dic))    # ['name', 'age', 'sex'

# 5、取值，存在时返回value，不存在时返回None
dic={'name':'egon','age':18,'sex':'male'}
res=dic.get('name')
print(res)  # egon

# 6、dic.fromkeys()的用法，初始化一个字典
l=['name','age','sex']
# 方式一：
dic={}
for k in l:
    dic[k]=None
print(dic)      # {'name': None, 'age': None, 'sex': None}

# 方式二：
dic=dic.fromkeys(l,None)
print(dic)      # {'name': None, 'age': None, 'sex': None}

# 7、update的用法
dic1={'name':'jack','age':22}
dic2={'sex':'male','address':'sh'}
dic1.update(dic2)
print(dic1)     # {'name': 'jack', 'age': 22, 'sex': 'male', 'address': 'sh'}

# 8、dic.setdefault():有值则不动原值，返回原值；没有则添加，返回添加的值
d={'name':'jack','age':23}
res=d.setdefault('age',32)
print(d)        # {'name': 'jack', 'age': 23}
print(res)      # 23

res1=d.setdefault('sex','male')
print(d)        # {'name': 'jack', 'age': 23, 'sex': 'male'}
print(res1)     # male

元组

定义方式：在()内用逗号分隔开多个任意类型的值

tup=(1,5.1,'name',[3,'a'],('a','c'))    # tup=tuple((1,5.1,'name',[3,'a'],('a','c')))
print(tup,type(tup))

t=tuple('hello')    # 将字符串转成元组
print(t)    # ('h', 'e', 'l', 'l', 'o')

# 1、按索引取值（可正向、可反向），但是只能取，不能改
t=(1,5.1,'name',[3,'a'],('a','c'))
print(t[2])      # name
print(t[3])      # [3,'a']
# 需要注意的是：元组中有列表时可以修改列表内包含的值，不会改变元组的内存地址
t[3][0]=5
print(t)    # (1, 5.1, 'name', [5, 'a'], ('a', 'c'))

# 2、切片（顾头不顾尾，可加步长）
t1=(1,3,5,7,2)
print(t1[1:3])      # (3, 5)

# 3、长度
t=(1,5.1,'name',[3,'a'],('a','c'))
print(len(t))       # 5

# 4、成员运算
t=(1,5.1,'name',[3,'a'],('a','c'))
print('name' in t)     # True
print(5.1 in t)     # True

# 5、循环
t=(1,5.1,'name',[3,'a'],('a','c'))
for item in t:
    print(item)

# 6、统计个数，索引位置
t=('a','b','c','a')
print(t.count('a'))     # 2
print(t.index('a',1,10))    # 3（a 的位置在第三）
print(t.index('xxx',1,10))      # 报错：tuple.index(x): x not in tuple

集合

定义方式：在{}内用逗号分隔开多个值

1、用途: 关系运算,去重
 
2、集合的三大特性:
     2.1 每一个值都必须是不可变类型
     2.2 元素不能重复
     2.3 集合内元素无序 

• 集合的用法（关系运算）

python={'牛热单','李大钊','慈溪','王公公'}
linux={'王公公','egon','张砸蛋','李大钊'}
# 求并集
print(python | linux)
print(python.union(linux))
# {'egon', '李大钊', '牛热单', '慈溪', '张砸蛋', '王公公'}

# 求交集
print(python & linux)
print(python.intersection(linux))
# {'王公公', '李大钊'}

# 求对称差集
print(python ^ linux)
print(python.symmetric_difference(linux))
# {'egon', '牛热单', '慈溪', '张砸蛋'}

# 差集
print(python - linux)
print(python.difference(linux))
# {'慈溪', '牛热单'}

s1={1,4,3,2}
s2={3,1,2,4}
# 是否相等
print(s1 == s2)     # True

# s1是否是s2的父集
print(s1 >= s2)     # True

# s2是否是s1的子集
print(s1 >= s2)     # True

s={1,3,2}
# update 往集合内更新值
s.update({4,6,7})
print(s)    # {1, 2, 3, 4, 6, 7}

s={1,3,2,4,7,6}
# pop 删除值(从左往右依次删除，并返回删除的值)
res=s.pop()
res1=s.pop()
print(res)      # 1
print(res1)     # 2
print(s)    # {3, 4, 6, 7}

# remove / discard 可以指定某些值，将其单纯的删除，返回None
s={1,3,5,7}
s.remove(3)     # 注：删除的值不存在时会报错
print(s)    # {1, 5, 7}
s.discard(5)    # 注：删除的值不存在时不会报错
print(s)    # {1, 7}


# 追加add(只往最后加)
s1={1,3,2}
s1.add(5)
print(s1)   # {1, 2, 3, 5}


s={1,3,5}
s1={2,3,6}
s.difference_update(s1)
print(s)    # {1,5}

• 集合去重

有局限性
1、无法保证原数据类型的顺序
2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重

全部是不可变类型的值去重

names=['alex','egon','alex','alex','egon','lxx']
s=set(names)
print(s)
l=list(s)
print(l)

# {'lxx', 'egon', 'alex'}

当含有可变类型时用集合去重会报错！！

stus_info=[
    {'name':'egon','age':18},
    {'name':'alex','age':73},
    {'name':'oldboy','age':84},
    {'name': 'egon', 'age': 18},
    {'name': 'egon', 'age': 18},
    {'name': 'egon', 'age': 18},
    {'name': 'oldboy', 'age': 84},

]

# set(stus_info) # 报错

l=[]
for info in stus_info:
    if info not in l:
        l.append(info)

stus_info=l
print(stus_info)

• 数据类型分类总结

布尔

只有两个值：True/False
判断结果真时，显示True
print(3>2)
# True

判断结果假时，显示False
print(3<2)
# False

#所有数据类型都自带布尔值
1、None，0，空（空字符串，空列表，空字典等）三种情况下布尔值为False
2、其余均为真

基本运算符

• 数学运算

• 比较运算

• 逻辑运算

• 赋值运算

• 身份运算

 

流程控制之if判断

作用：做判断，让计算机可以模拟人类的方式去工作

• if...（单分支）

age = 23
if age<22:
    print('小姐姐好')

• if...else（双分支）

age = 23
if age<22:
    print('小姐姐好')
else:
    print('大姐姐好')

• if...elif...else（多分支）

age=21
Age=int(input('please guess:'))
if Age > age:
    print('too bigger')
elif Age < age:
    print('too smaller')
elif Age == age:
    print('you are right')
else:
    print('something was wrong')

• if嵌套

age = 23
height=168
weight=55
successful=True
if age<22 and age >19 and height >170 and weight < 54:
    print('I love you')
    if successful:
        print('feel so good')
    else:
        print("I'm hated")
else:
    print('大姐姐好')

流程控制之while循环

作用：可以使计算机模拟人类重复做事的方式去工作

• while语句

count=0
while count<100:    # 如果条件永远成立时就会发生死循环
    print(count)
    count+=1

• while....break/continue（循环的结束语句）

nm = 'egon'
pwd = 123
tag = True
count = 0
while tag:
    name = input('username>>:')
    password = int(input('password>>:'))
    if name == nm and pwd == password:
        print('login successful')
        while tag:
            cmd = input('>>>:')
            if cmd == 'q':
                tag = False
                break
    else:
        print('wrong')
    count += 1
    if count > 2:
        if count == 3:    
            x=input('once again?(y/Y)>>:')
            if x == 'y' or x == 'Y':
                count=0    #当输错3次后将count改为0，就会再循环3次。。。
            else:
                break
# 如果想在最内层的while循环结束所有的父循环时，可以在父循环开始之前将True条件赋值给一个变量，然后再最内层循环结束之前让变量等于Flase，就可以结束所有循环

# 实现打印商品详细信息
# 用户输入商品名和购买个数
# 将商品名，价格，购买个数加入购物列表
# 如果输入为空或其他非法输入则要求用户重新输入

msg_dic = {
    'apple': 10,
    'tesla': 100000,
    'mac': 3000,
    'lenovo': 30000,
    'chicken': 10,
}

shopping_cart = []
while True:
    for k, v in msg_dic.items():
        print('%s : %s' % (k, v))
    choice = input('please choose>>:')
    if choice not in msg_dic or not choice:
        print('......something was wrong.......')
        continue    #跳出本次循环，后面的代码将不执行
    count = input('please enter count>>:')
    if not count.isdigit():
        continue    #跳出本次循环，后面的代码将不执行
    shopping_cart.append((choice, msg_dic[choice], count))
    print(shopping_cart)

#注意点：continue不能加在执行代码的最后一步，否则没有任何意义

while与else的用法详见for循环

流程控制之for循环

作用：可以不用依赖于索引取值

我们之前学过列表的取值方法就是根据列表的特点，按照位置索引去取值。

l=['a','s','d']
print(l[0])
print(l[1])
print(l[2])

也可以用循环实现取值

l=['a','s','d','f']
res=0
while res < len(l): #len(l)=4,还是按照索引取值
    print(l[res])
    res+=1

但是我们学过的数据类型不止列表一种，那对于字典来说还能用索引取值吗？  肯定不行，所以就用到了for循环取值的方法

# 所以上面的列表取值我们可以这样写
l=['a','s','d','f']
for x in l:     # x 变量名，从列表中取出一个值然后赋值给x,这样一直循环将值取完
    print(x)

# so 当我们遇到字典要取值时，就像这样吧！

dic={'a':1,'b':2,'c':3,'d':4}
for k in dic:
    print(k)    #此时，取出的是字典的key,再取到value那不就so easy了！

dic={'a':1,'b':2,'c':3,'d':4}
for k in dic:
    print(k,dic[k])

当然我们之前学if判断的时候学过一种if语句------if....else

那对于for循环来说有没有for....else这么一说呢？？let's see

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
for k in dic:
    print(k, dic[k])
else:
    print('______love')

# a 1
# b 2
# c 3
# d 4
# ______love

但是需要我们注意的一点是，上面的代码运行如果碰到break会怎样呢？？

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
for k in dic:
    if k == 'c':
        break
    print(k, dic[k])
else:
    print('______love')

# a 1
# b 2

所以：它就是这个样子咯！！！