Python语言基础

字符串方法：

my_string ="Hello, world!"

 

1、len()  获取字符串长度 ：len(my_string )     #13

2、find()  查找子字符串 : my_string.find("W")    # 7   

若多次出现，则返回第一次出现的位置；若查找两个字符串，则返回第一个字符出现的位置；若结果为负数，则表示查找的字符没有出现在字符串中。

3、count()   子字符串出现的次数 : my_string .count("l")    # 3

4、in 和not in 是否包含子字符串    "Hello" in my_string    #True

5、replace()   字符串替换   my_string.replace("o", "-")    # "Hell-, w-rld!"      

my_string.replace("o", "")    # "Hell, wrld!"

my_string.replace("8", "*")    # "Hello, world!"

6、child=my_string.split(",")   #["Hello","world!"]

执行以上操作不会对原字符串产生影响

 

转义字符：

\"  表示  "

\'            '

\n            换行

\t              制表符Tab

\\              \

输出    字符串要用' 或者" 包围起来

print("字符串要用'或者 \"包围起来 ")

 

转义字符：转换字符原本的意义

r"..."  表示原始字符串

C:\test路径   r"C:\test路径" 

"""  创建多行字符串

格式化字符串

将其他类型数据按照指定格式转换成字符串

F-String(Python 3.6++才有)     result=F"小明今年{age}岁了！"或f"小明今年{age}岁了！"

Format()        result="你好{},今年{}岁了！".format(name,age)     {}为占位符，放age

格式化数字

以:开头对数字进行格式化

[[填充]对齐][符号][宽度][.精度][类型]

以上设置，要注意先后顺序

pi:.2f   .2表示保留两位，f表示float类型

pi:.2% -->   314.15%

a=25   a:b --> 11001  b表示二进制，o八进制，x十六进制

逻辑运算优先级

**  

* / % //

+-

> < >= <= !=

and  or  not 

=

if  else  elif

if语句中可以添加elif处理额外的判断条件，else处理上述条件外的其他情况

if A:

      代码...

elif B:

       代码...

else:

        代码...

       

列表和下标

列表下标从0开始，可以使用下标获取元素  my_list[2]

列表页可以使用负数下标     my_list[-1]表示最后一个元素

可以使用[start:end:step]对列表进行截取  my_list[1:4]

a=[]  a是空列表

字符串是不可变类型，列表是可变数据类型

使用加法+ 拼接两个列表

使用乘法* 重复某个列表

使用reverse()反序列表，会改变原列表

max()取列表中最大的元素  max(a)

min()取列表中最小的元素   min(a)

sort()排序    a.sort()会改变列表

len()    长度

in  not in判断元素是否在列表中

 

a[4],a[5]=a[5],a[4] 交换位置

s1=a.split(",")按逗号拆分

s2="".join(a)  把列表合并成一个字符串 ""内可加*等符号

a.append(5)  把5加到列表末尾

a.insert(1,"hi")   hi加到下标为一的位置，当下标为负数是，先把负数转为正数再倒数，加到列表中

a.extend([5,6,7])   把5,6,7依次加到列表末尾，加[]表示按列表插入，不加表示按字符插入

a.pop()移除列表最后一个元素

a.pop(2)，del a[2] 删除下标为2的元素

a.remove("b") 将b元素移除

a.clear()  清除列表

 

元组tuple

a=(1,2,3)

元组也是一种有序容器，也使用下标索引元素，也可以截取，in,  not in ,max,min,+,*,与列表不同的是，元组是不可变类型，没有增删改，只能查

系统对元组处理比列表高，元组可做为字典的key列表不可以，元组可以同时给多个元素赋值

t=(1,2,3)  a,b,c=t

range方法

使用range()可以快速生成指定范围内的列表元素。

1.range(end) 生成0-end之间的整数，不包含end

l3=list(range[100])    #{0,1,2,3,...99}

2.range(start,end) 生成start和end之间的整数，不包含end

range(4,12)    #4,5,6,7,8,9,10,11

3.range(start,end,step)生成star到end之间的整数，不包含end，并且每隔step隔数字生成一个数字

range(3,9,2)    #3,5,7

 

列表遍历

l=[2,4,6,8,10]

for循环

for item in l

      print(item)

pass 就是一个占位符，可以保证格式不报错，但是不执行。

for _ in range(10)

      print("python")       #重复打印十遍python，_ 表示没有名字，上面item为起的名字

while循环

while 条件表达式：

          循环体...

循环控制关键词break和continue

循环中使用break可以终止整个循环

循环中使用continue可以终止本轮循环，继续下一轮循环

 

使用for循环可以准确控制循环次数

不确定循环次数但知道循环结束条件时，可以使用while循环

 

列表推导式：

可以快速构建新的数据序列

[表达式 for 变量 in 列表]

 

l1={1,2,3,4}

l2=[i*2 for i in l1]   #[2,4,6,8]

 

l=[i//2 for i in range(10) if i %2==0]

 

l=[str(i) for i in range(10) if i %2==0]

 

l=[i for i in "hello"]    # ['h','e','l','l','o']

 

print("b","a",18,sep="-")   #b-a-18

print("b","a",18,end="-")   打印完以后，结束符后加的东西，如果不写就是换行

print(f"{i}*{j}={i*j:2d}") 表示i*j的宽度是2

 

字典基础

字典Dictionary也是一种可变容器类型，可以保存任意类型对象

字典中的元素以键值对Key-Value的方式存储

字典中的键必须是唯一的不能重复，必须是不可变类型

d={}    #空字典

d={key1:valueq1,key2:value2}

d={"北京":22,"上海":24}

#查

d["北京"]   #22 要确保在字典中，否则会报错

name=d.get("沈阳") 

name=d.get("沈阳",-1)   若不在字典中，把-1赋值给name，字典本身不会发生变化

name=d.setdefault("AA") 

name=d.setdefault("AA",-1)   若不在字典中，会直接把AA和-1加到字典中

#改

d["北京"]=20  #d={"北京":20,"上海":24}

#增

d["广州"]=23  #d={"北京":20,"上海":24,"广州":23}

d.update({"石家庄":20,"武汉":10})    update后加的是字典，把字典中的所有元素都加入到d中

#删

d.pop("北京")   #d={"上海":24,"广州":23}  要确保在字典中，否则会报错

v=d.pop("北京",-1)  表示如果d中有北京就把北京删除，并把-1赋值给v，若没有北京，只把-1赋值给v

d.clear() 清空字典

#获取地点的长度

len(d)

#把字典转换为字符串

str(d)

#判断指定的key是否包含在字典中

"广州" in d     "广州" not in d

 

字典也是可迭代对象(可以每次只获得一个元素)，可以使用for遍历

#遍历所有的键key

for k in d.keys()

#遍历所有的值value

for v in d.values()

#遍历所有的键和值key-value

for k,v in d.items()

s=dict(a=1,b=2,c=3)

for i in s:

       print(f"key={i},value={s[i]}")

#key=a,value=1

key=b,value=2

key=c,value=3