数据类型:

运算符

=：赋值运算符

a=10# 此时将10赋值给a，所以a的结果就是10

a=50# 此时a的结果是50

在整个过程中，10和50的值没变，所以它们属于常量，而a的值发生改变，所以a属于变量

2.查看类型：type(10)

3.变量类型

int:整数数字

float:浮点数(小数)

str:字符串，""或''包含的内容称为字符串

布尔类型：

True：真

False：假

4.标识符(变量)命名规则：

字母、数字、_组成

不能以数字开头

不能和关键字重名

尽量做到见名知义

尽量避免与变量类型重复

5.标识符(变量)命名方法：

尽量遵循，让标识符更容易识别

小驼峰命名法： studentAge = 20

大驼峰命名法： StudentAge = 20

_连接： student_age = 20

6.关键字：

None:空

7.输出：print

格式化输出：一一对应

%d:输出有符号十进制整型数字

%f:输出小数，默认小数点后6位，用%.2f输出两位小数

%s：输出字符串

name="小明"

a=15.5

b=4.5

print("%s午餐消费%.2f元,剩余%.2f元"%(name,a,b))

8.输入：input

输入的任何数据都是字符串类型

9.算术运算符：

1+2->31*2->21-2->-11/2->0.5求出最后结果,浮点类型1//2->0取商1%2->1取余1**2->1两个1相乘

10.复合赋值运算符

a=2a+=2# a = a + 2  -> a:4a-=1# a = a - 1 -> a：3a*=2# a = a * 2  ->  a: 6a/=1# a = a / 1 -> a:6.0a**=2# a = a ** 2 -> a:36

11.类型转换

*int:将字符串类型转换为数字类型，字符串里面必须全部是数字字符

a="20"

b=int(a)

# b:20, type(b)  -> int

*float：可以将像浮点数的字符串变为浮点数

a="12.3"

b=float(a)

# b: 12.3 , type(b) -> float

*str:将其他类型转换为字符串

a=12

b=12.56

c=str(a)

# c: '12', type(c) -> strd=str(b)

# d: '12.56' , type(d) -> str

字符串下标

*对字符串的每个元素进行编号: 下标从0开始，每个下标都是整数

s="hello"

# 下标范围: 0-4

*通过下标来取出字符串中的元素

# 字符串名字[下标]

s="world"

print(s[2])       # r

*下标为负，从右边第一个：-1到左边第一个-n

s="hello"

s[-1]      # os

[-5]        # h

切片

字符串[起始:结束:步长]

步长为正，方向从左到右，起始 < 结束

步长为负，方向从右到左，起始 > 结束

包头不包尾

字符串操作

1、查找

find：左->右,找到左边第一个就返回下标，一直找不到，就返回-1

rfind: 右-> 左，找到右边第一个就返回下标，一直找不到，就返回-1

index：左->右,找到左边第一个就返回下标，一直找不到，报错

rindex：右-> 左，找到右边第一个就返回下标，一直找不到，报错

count:  统计出现的次数

2、替换

1.replace

s="hello python,hello world"

s.replace(","," ")      # 将，替换为空格，此时s本身没有改变

s=s.replace(","," ")  # 通过重新赋值，s本身改变

2.分割

split：标志存在，按标志切分，标志不存在,整个字符串不分割

spplit()中不写任何标志，默认按空格分割，且会去除空字符串

3、拼接

join：将每个单词按照标志连接在一起

4、分割字符串中所有单词

s="hello python, hello  world, hello china"

# 1. 标志不统一，替换统一s=s.replace(","," ")

# 2. 分割字符串l=s.split()# l:  ['hello', 'python', 'hello', 'world', 'hello', 'china']

# 3. 按 "-" 拼接l# "-".join(l)# "+".join(l)

5、大小写转换

upper() 小写--》大写

lower() 大写 --》 小写

title() 将字符串中每个单词的首字母大写，其他字母小写

6、判断

isdigit：判断字符串中是否全部是数字

isalpha: 判断全是字母

isalnum: 判断是否是字母或数字

endswith：判断是否以某个字符串结尾

startswith： 判断是否以某个字符串开头

7、去掉空白

strip：去掉两边空白字符

lstrip:去掉左边空白字符

rstrip:去掉右边空白字符

列表格式

用一对[]包括的数据，称为列表(list)

列表中存放的数据类型都可以

l=[12,34]

l2=["12",23,45.6]

列表循环遍历

l=[12,"12",1.2]

for  i  in  l:

print(i,type(i))    # 12  int   # 12  str  # 1.2 float

列表元素修改

添加

append(a):在列表末尾添加元素a

insert(i, a):将元素a插入到下标为i的位置

extend(a)：将元素a中的每个成员依次添加到列表中

>>>l

[   ]

>>>l.extend("hello")

>>>l['h','e','l','l','o']

>>>l.extend([2,3,4,5])

>>>l['h','e','l','l','o',2,3,4,5]

>>>

append和extend区别：

>>>l=[  ]

>>>l.append([1,2])

>>>l[[1,2]]

>>>l.extend([1,2])

>>>l[[1,2],1,2]

删除

pop():默认删除列表最后一个元素

pop(i):删除下标为i的元素

remove(a):删除值为a的元素，不存在，报错

del a ：将变量a删除

修改：

通过下标的方式修改

l  = [1,2,3]

l[1]="2"             #  l: [1, "2", 3]

查：

index: 存在，返回下标，不存在，报错

in ：存在，True，不在，False

not in: 不在，True， 存在， False

count: 统计出现的次数

列表嵌套

In[33]  :  l

Out[33]  : [12,[34,['13',43,67],78]]

In[34]  :  l[1][1][0]   =  13

In[35]  :  l

Out[35]  :  [12,[34,[13,43,67],78]]

常用函数

求元素个数：len()

求最大值：max()

求最小值：min()

求列表中所有数字和：sum()

排序：

默认从小到大：sort()

从大到小： sort(reverse=True)

顺序反转，大小不排序

reverse()

reverse实例

In[1]    :    l    =    [12,3,45,21,56]

In[2]    :    l.reverse()In[3]    :l

Out[3]    :    [56,21,45,3,12]

sort实例

In[5]    :    l

Out[5]    :    [56,21,45,3,12]

In[6]    :    l.sort()

In[7]    :    l

Out[7]    :    [3,12,21,45,56]

sort(reverse=True)实例

In[7]    :    l

Out[7]    :    [3,12,21,45,56]

In[8]    :    l.sort(reverse=True)

In[9]    :    l

Out[9]    :    [56,45,21,12,3]

元组

格式：

a=(1，2，3)   #a: tuple、元组

元组不能增、删、改其中的数据，但是可以直接删除整个元组

查找

index： 按照值去查找，存在，返回下标，不存在，报错

count： 存在，返回存在的次数，不存在，返回0

in: 判断是否在其中，在，True，不在，False

not in: 判断是否不在其中，不在，True， 在， False

字典(dict)

格式

# {键：值}, 两者合称为键值对，多个键值对之间"，"隔开

# d = {"a":1}

In[77]  :  student  =  {"name":"贾长阳","age":21,"gender":"未知"}

In[78]  : student["name"]

Out[78]  :  '贾长阳'

In[79]  :   student["age"]

Out[79] : 21

In[80]  :  student["gender"]

Out[80]   :  '未知'

增、改

字典中键如果存在，属于修改，不存在，属于增加

In[97] : d

Out[97] : {'a':1,'ddd':250}

In[98]  : d["a"]  =  100    #修改

In[99]   :  d

Out[99]  :   {'a':100,'ddd':250}

In[100]  :  d["e"]   =  150   # 添加

In[101]  :  d

Out[101]   :  {'a':100,'ddd':250,'e':150}

删除

In[104]  :  d

Out[104]  :  {'a':100,'ddd':250,'e':350}

In[105]  :  deld["ddd"]   # 删除字典中键名为"ddd"的项

In[106]   :   d

Out[106]  :   {'a':100,'e':350}

In[107]  :  deld     # 删除整个字典

查

in

not in

技能通过字典，获取信息，并保存到字典中

# 1. 用户输入个人信息：姓名， 年龄， 地址， 身高， 体重

# 2. 分别存到字典中

# 3. 输出个人信息

person={}     # 空字典

name  =  input("输入姓名:")

person["name"]  =  name

person["age"]  =  int(input("输入年龄:"))

person["address"]  =  input("输入地址:")

person["height"]  =  int(input("请输入身高(cm)："))

person["weight"]   =  float(input("输入体重(kg)"))

print(person)

理论:字典的3种遍历方式

# 遍历字符串

s  =   "hello world"

for  i   in  s:

print(i)

# 遍历列表

l  =  [1,2,3,4]

for  i  in  l:

print(i)

# 遍历元组

a  =  (1,2,3,4,5)

for  i   in   a:

print(i)

# 遍历字典

ddd  =   {"a":1,"b":2,"c":3,"d":4}

for  i  in  ddd:      # 默认遍历字典的键

print(i)

# 通过keys来遍历字典的键

for  i  in  ddd.keys():

print(i)

# 通过values来遍历字典中的值

for  i   in   ddd.values():

print(i)

# 通过items来遍历字典的键值对，得到一个包含键和值的元组

for  i  in  ddd.items():

print(i)

集合

s  =  {1,2,3}    # s：集合

s2  =  set()   # s2:空集合

l=[  ]   # 空列表

d={ }   # 空字典

# a = ()  # 空元组

集合特性

元素唯一

元素无序

集合方法

添加

add:添加一个元素

update:将每个元素依次添加

In[38]:s  =  set()

In[39]:s.update("hello")

In[40]:s

Out[40]:{'e','h','l','o'}

In[41]:s.add("hello")

In[42]:s

Out[42]: {'e','h','hello','l','o'}

删除

remove:按元素的值删除，不存在，报错

discard：按元素的值删除， 不存在，不报错

pop: 随机删除

内置函数

max(): 求最大值

min(): 求最小值

len(): 求元素个数

del : 删除元素

公共方法

+ ： 数字之间、字符串之间、列表之间、元组之间

*： 数字之间、"hello" * 4, [1, 2] * 2 , (1, 2) * 2

in:

not in:

In[9]: "7"      in"17"

Out[9]:TrueIn

[10]:  7        in(17,27)

Out[10]  :  False

In[11]  :  7         in[17,27]

Out[11]  :  False

In[12]  :  7         in{17,27}

Out[12] : False

In[13] : 7            in{"a":17,"b":27}

Out[13]  : False