Python基础（1）

最新推荐文章于 2022-11-03 17:49:53 发布

aCandy93

最新推荐文章于 2022-11-03 17:49:53 发布

阅读量388

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/qq_30365153/article/details/79386889

版权

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

type(变量名):测试变量类型。
\n:换行。
“%d”%变量名:可直接替换为不同类型的变量名。
- %d:整数变量，%s:字符串变量。
input():输入框。

运算符：

%:取余。
//：取整数(两数相除，无论是什么类型都只取整数)。
**:乘幂。

逻辑运算符：

and:与。同JAVA中的&符号。
- or:或。同JAVA中的|符号。
- not:非。同JAVA中的!符号。
random.randint(最小数，最大数):生成随机数。
if elif else语句

#多个条件判断时elif使用方式。
if 条件:
    执行语句
elif 条件:
    执行语句
elif 条件：
    执行语句

while语句

i=9
a=1
while 0<=i:
    j=1 
    if i>=5:
        while j<=a:
            print("* ",end="")
            j+=1
    else:
        while j<=i:
            print("* ",end="")
            j+=1
    print("")
    i-=1
    a+=1 
print("------------分割线------")
i=1
a=4
while i<=9:
    j=1
    if i<=5:
        while j<=i:
            print("* ",end="")
            j+=1
    else:
        while j<=a:
            print("* ",end="")
            j+=1
        a-=1    
    print("")
    i+=1 
打印图案如下：
* 
* * 
* * * 
* * * * 
* * * * * 
* * * * 
* * * 
* * 
*

break和continue的区别：break是结束所在循环，执行后面代码。continue是结束当前所在循环，如还有剩余循环，就继续循环。
for xxx in xxx循环

for循环：
for 临时变量 in 数据：
    执行语句
例：
    name = "aCandy"
    for temp in name:
        print(temp)

切片：
string[int：int（结束角标不会提取，提取角标前一字符）:int（每次取的跨度）]
例：

name = "abcdef"

#意思就是从0角标开始取值，取到角标5的前一位（也就是角标4），每跨两个角标取值。
name[0:5:2]

#打印结果如下：
ace

range()函数
参数和切片参数类似


#第一个参数为开始角标，第二个为结束角标（输出该角标前一个角标），第三个为步长

for num in range(0,5,2):
print(num,end=" ")


#输出结果如下：

0 2 4

字符串常用函数

data = ” hello world! how are you? i miss you! “
- title()
以首字母大写显示数据
- upper()
转换数据中所有字母为大写。
- lower()
转换数据中所有字母为小写。
“`python
data = “hello world! how are you? i miss you!”

#首字母大写
print(data.title())
#所有字母大写
print(data.upper())
#所有字母小写
print(data.lower())

#打印结果如下
Hello World! How Are You? I Miss You!
HELLO WORLD! HOW ARE YOU? I MISS YOU!
hello world! how are you? i miss you!
```

- 字符串合并
“`python
data = “hello world! how are you? i miss you!”
data_2 = “good bye.”
print(data+” “+data_2)

#打印结果如下
hello world! how are you? i miss you! good bye.
```

- \n、\t
\n：换行符。 \t：制表符
- find(“world”):查找该数据在字符串中的位置，以角标显示。查找不存在的字符时会提示-1。
- index(“hello”):index函数和find函数基本一样，区别在于index方法查找不存在的字符时会抛出异常。
- rfind(“you”):此函数查找方向是从右往左查找，角标方向不变，适用于有相同数值时查找。
- rindex(“hello”):同理rfind(),异常抛出同index()。
- count(“you”):查找该数据在字符串中出现的次数。
- count(“you”,3,23):查询”you”出现的次数，从第3个位置查询到第23个位置。
- len(data):查询数据长度，从1开始计数。
- replace(“hello”,”hi”):将原来数据中的”hello”替换为”hi”，但只是临时数据，需再次定义变量赋值。
- split(” “):分割数据函数，此处以空格分割。
- capitalize():第一个单词数据首字母大写。
- startswith(“hello”):判断数据是否是以”hello”开头，是就返回true,反之false。
- endswith(“you!”):判断数据是否以”you!”结束，是返回true，反之false。
- strip():删除数据前后的空白字符。
- lstrip():删除数据左边的空白字符。
- rstrip():删除数据右边的空白字符。
删除空白后的值需要重新以变量存储
- partition(“how”):将数据字符串以”how”为准分割成三部分，”how”前，”how”和”how”后。
- isalpha():判断数据是否是纯字母，是返回true，反之返回false。（不包含换行符）
- isdigit():判断数据是否是纯数字，是返回true，反之返回false。
- isalnum():判断数据是否是纯字母或数字（可以数字和字母组合）。是返回true，反之返回false。
- isspace():判断数据是否只包含空格，是返回true，反之返回false。

字符串的join函数

用字符串里的join函数将数组连接起来。

data = ["my","name","is","aCandy"]
string = "_"
print(string.join(data))
#打印结果如下
my_name_is_aCandy

列表

Python中的列表等同于C和JAVA中的数组。[“jack”,”rose”,”aCandy”,”Jay”]
Python中列表里的数据类型可以不是同一类型。[“aCandy”,18,24.03,”good”]

列表中的每个数据叫做元素。输出每一个元素的方式叫做遍历。（概念通JAVA）


#遍历列表中的每个元素

data = ["aCandy",18,20.12,"sorry"]
for temp in data:
    print(temp)


#用while方式遍历列表

a = 0
while a<len(data):
    print(data[a])
    a+=1

#打印结果如下：

aCandy
18
20.12
sorry


#查询名字演示

studentName = ["jay","jack","aCandy","rose","ali","pite"]
name = input("请输入您的名字：")

#以一个标记来反馈遍历结果

flag = 0
for demoName in studentName:
    if demoName==name:
        flag = 1
        break
if flag==1:
    print("找到啦！")
else:
    print("没有找到！")

列表的常见操作（增删查改）

添加元素
- append()
  python #向列表末尾添加元素 names = ["aCandy","jack"] names.append("rose") print(names) #打印结果如下 names = ["aCndy","jack","rose"]
- insert()
  python #向列表的指定角标位置插入元素 names = ["aCandy","jack"] #向角标1插入"Jay"元素 names.insert(1,"jay") print(names) #打印结果如下 ['aCandy', 'jay', 'jack', 'rose']
- extend()
  python names = ["aCandy","jack"] names2 = ["num1","num2"] #extend函数是向一个列表中插入另一个列表 names.extend(names2) print(names) #打印结果如下 ['aCandy', 'jay', 'jack', 'rose', 'num1', 'num2']
  append()和extend()的区别：
  在插入列表时，extend()是将插入的列表里的元素单个提取放入到被插入的列表，而append()是将插入列表当做一个元素放入到被插入到的列表中。
修改元素
- 目前未需要具体函数，只需在列表中找到需要修改的元素角标即可修改
  python names = ["aCandy","jay","rose"] names[1]="jack" print(names) #打印结果如下 ['aCandy', 'jack', 'rose']
查找元素
- xxx（变量） in xxx（列表）
  如果变量数据存在于列表中，就返回true，反之为false。
```
names = ["aCandy","jay","rose"]
name = "rose"
print(name in names)

#打印结果如下

True


#之前的查询方法

studentName = ["jay","jack","aCandy","rose","ali","pite"]
name = input("请输入您的名字：")

#以一个标记来反馈遍历结果

flag = 0
for demoName in studentName:
    if demoName==name:
        flag = 1
        break

if flag==1:
    print("找到啦！")
else:
    print("没有找到！")  
```
- xxx（变量） not in xxx（列表）
  如果变量数据不存在于列表中，就返回true，反之为false。
  python names = ["aCandy","jay","rose"] name = "jack" print(name not in names) #打印结果如下 True
- index()
  列表的index()方法和字符串的使用方法一样，如果有该元素就返回该元素的角标，没有就抛出异常。
  python names = ["abcdef","string","sasasasa"] print(names.index("string")) #打印结果如下 1
  需要注意的是：列表没有find()函数。
- count()
  查询该元素在列表中出现的次数。不存在的元素自然就返回0.
  python names = ["a","s","s"] print(names.count("a")) #打印结果如下 1
删除元素
- del xxx(列表)[角标值]
  根据角标删除元素
  python names = ["a","s","s","we","www"] del names[0] print(names) #打印结果就是删除了0角标的"a"元素
- xxx(列表).pop()
  从列表末尾删除元素。
  python names = ["a","s","s","we","www"] names.pop() print(names) #打印出来的结果就是删除了"www"元素
- xxx(列表).remove()
  根据元素值删除列表中对应的元素。
  python names = ["a","s","s","we","www"] names.remove("we") print(names) #打印结果就是删除了"we"元素
  需要注意的是，如果列表中有相同的删除，删除的时候从左往右删除。

综合应用


#增删改查练习，班级花名册系统。


#定义花名册列表，存储班级学生姓名。

names = []
while True:
    print("-"*20)
    print("欢迎使用班级花名册系统")
    print("1.添加姓名")
    print("2.删除姓名")
    print("3.查询姓名")
    print("4.修改姓名")
    print("5.查看所有姓名")
    print("0.退出系统")
    print("-"*20)
    num = input("请输入数字执行相应操作：")
    if num =="1":
        name = input("请输入要添加的姓名：")
        names.append(name)
    elif num =="2":
        names.remove(input("请输入要删除的姓名："))
    elif num =="3": 
        name = input("请输入要查询的姓名：")
        num1 = names.index(name)+1
        print("您查询的学生姓名在花名册的第%d位"%num1)
    elif num =="4":
        name = input("请问您要修改谁的姓名？请输入：")
        num2 = names.index(name)
        names[num2] = input("请输入你要修改的新姓名：")
    elif num =="5": 
        print(names)
    elif num =="0":
        break
    else:
        print("您的输入有误，请重新输入。")

排序
- sort()
  默认将列表从小到大排列，如要从大到小，在函数内输入”reverse=True”
```
nums = [12,232,32,434,54,546,5454,99]
nums.sort()

#打印结果是从小到大排序

print(nums)

nums.sort(reverse=True)

#从大到小排序

print(nums)
```
- reverse()
  将元素从头到尾排成从尾到头。也就是逆序。
  python nums = [12,232,32,434,54,546,5454,99] nums.reverse() print(nums) #打印结果如下： [99, 5454, 546, 54, 434, 32, 232, 12]
  补充：字符串也可以排序，利用ASC码表排序，以A-Z的顺序，先比较第一个字母，再第二个，以此类推。

列表的嵌套

Python支持列表中嵌套列表。
- 列表嵌套应用
将8个老师随机分配进3个办公室。
python import radom #定义一个嵌套列表，用于办公室。 rooms = [[],[],[]] #定义8个老师姓名 names = ["A","B","C","D","E","F","G","H"] #定义随机数，用于随机添加进办公室 for name in names: rooms[random.randint(0,2)].append(name) print(rooms)

元祖

元祖和列表类似，区别在于元祖以括号存储，且不能修改。只要不是修改元素，元祖的操作函数和列表基本类似。

字典

以大括号存储的键值对数据类型。如：
{key:values,key:values} 和JAVA一样，键不能相同，值可以相同。
- 查询元素
- get()
通过获取键查询值，如果没有亦可赋值。
python myInfo = {"name":"aCandy","age":"24","sex":"man","wife":"null"} #不使用函数通过键获取值的方法，如果是未定义的键会报错。 print(myInfo["wife"]) print("--------------") #使用get()函数通过键获取值的方法，如果是未定义不会报错，且可以赋值。 print(myInfo.get("ss","heihei"))
- 修改元素
python myInfo = {"name":"aCandy","age":"24","sex":"man","wife":"null"} myInfo["name"] = "jack" print(myInfo)
注：Python字典没有set()函数
- 添加元素
字典添加元素非常简单，直接定义元素并赋值即可。
python myInfo = {"name":"aCandy","age":"24","sex":"man","wife":"null"} myInfo["high"]=163 print(myInfo) #打印结果如下： {'age': '24', 'sex': 'man', 'wife': 'null', 'name': 'jack', 'high': 163}
- 删除元素
- del xxx(字典名)[xxx]（键名）
根据键名删除值
python myInfo = {"name":"aCandy","age":"24","sex":"man","wife":"null"} del myInfo["name"] #打印的结果就会删除“name”的值 print(myInfo)
- clear()
清空整个字典里的数据，但保留字典空对象。
python myInfo = {"name":"aCandy","age":"24","sex":"man","wife":"null"} myInfo.clear() print(myInfo) #打印结果如下： {}
- len()
len(xxx(字典名))，如：len(myInfo)。查询字典内键值对的个数。
- key()
myInfo.key() 查询字典内的所有键名。
- values()
myInfo.values() 查询字典内的所有值。
- items()
myInfo.items() 以列表嵌套元祖的方式返回每组键值。
python myInfo = {"name":"aCandy","age":"24","sex":"man","wife":"null"} print(myInfo.items()) #打印结果如下： dict_items([('age', '24'), ('sex', 'man'), ('wife', 'null')])
- key in xxx(字典名) Python3函数
“name” in myInfo 判断字典中是否有该键名。有就返回True，反之就返回False。
“`python
myInfo = {“name”:”aCandy”,”age”:”24”,”sex”:”man”,”wife”:”null”}
#打印的返回结果当然是True。
print(“name” in myInfo)

#在Python2中，函数是has_key()。Python3已废弃该函数。
myInfo.has_key("name")
```

字典的遍历

myInfo = {“name”:”aCandy”,”age”:”24”,”sex”:”man”,”wife”:”null”}
- 遍历字典的键
for key in myInfo.keys()
python for key in myInfo.keys(): print(key)
- 遍历字典的值
for value in myInfo.values()
python for value in myInfo.values(): print(value)
- 遍历字典的键值对
for temp in myInfo.items()
第二种写法更常用
“`python
for temp in myInfo.items():
#以元祖的方式返回每个键值对。
print(temp)

#常用第二种写法。将返回的元祖分别存于key和value变量中。
for key,value in myInfo.items():
    print(key)
    print(value)
```

函数

Python函数定义方式：
**def 函数名():
执行代码**
- 调用函数
  def 函数名()
  python #定义函数 def demo(): print("Python函数调用Demo") #调用函数 demo()

函数参数
和JAVA基本一样，区别在于Python的函数参数不需要输入数据类型。


#函数参数叫形参（类型参数）

def demo(num1,num2):
    print(num1+num2)

#调用时叫实参（实际参数）

demo(145,56)

缺省参数
当函数的形参设置默认值后，调用该函数时不给该参数传值时，就用默认值，如果传值就使用传值的参数。


#如果不向c传值的话就默认使用35这个值，如果传值就使用传值的参数。

def demo2(a,b,c=35):
    print(a,b,c)


#c的值传入33，函数执行时就使用33这个值。

demo2(11,22,33)

#没有给c传值，函数执行时默认使用35这个值。

demo2(11,22)

可以设置多个缺省参数，而且必须放置在没有设置缺省参数的变量后面

不定长参数
以元祖和字典作为形参，传入任意个数长度的参数。
*args是元祖，除定义参数外，任何未定义的参数都默认依次存储在元祖中。
**kwargs是字典，定义声明的参数存储在该字典中。

def demo2(a,b,*args,**kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)


#调用函数时的传参

demo2(11,22,33,44,55,66,77,name=11,sex=22,age=24)


#打印结果如下

11
22
(33, 44, 55, 66, 77)
{'sex': 22, 'age': 24, 'name': 11}

函数的文档说明
即在函数的第一行用双引号输入函数的注释信息，不会被打印


#函数参数

def demo(num1,num2):
    "这是文档说明，且这句话不会被执行，所以不会报错。"
    print(num1+num2)


#调用时传参

demo(145,56)

函数返回值
return 函数返回关键字

def demo(num1,num2):
    "这是文档说明"
    return num1+num2

made = int(input("输入数字："))
made2 = int(input("输入数字："))

#接收函数的返回值

test = demo(made,made2)
print(test)

函数的4种类型
- 无参数，无返回值
  python def demo(): print("hello world!")
- 无参数，有返回值
  python def demo(): a = input("输入数字：") return a
- 有参数，无返回值
  python def demo(num1,num2): print(num1+num2)
- 有参数，有返回值
  python def demo(num1,num2): return num1+num2
  Python最好定义主函数，提高代码可读性
局部变量和全局变量
函数内的声明的变量是局部变量，只在函数内有效。
函数外声明的变量是全局变量，能在多个函数中调用。
全局变量的值默认只能调用，不能修改（和Java不同，Java默认可以修改全局变量的值）
如果需要修改全局变量的值，需要用”global”关键字声明。
```
num = 56

def demo2():
    #声明可以修改全局变量的值
    global num
    num+=1
    print(num)

demo2()
```

引用

不可变数据类型：数字，字符，元祖。

a = 100
b =a
#此时a和b完全相同，值相同，内存地址也相同。
print(a)
print(b)


a=200
#a值更改为200
print(a)
#b的值还是100。因为数字是不可变数据类型，当a发生数字变化时，在内存中开辟新的区域存储200，用于a指向，但是b还是指向的100的内存地址，所以这里b的值不会随着a的变化而变化。
print(b)

可变数据类型：列表，字典。

c = [100,200]
d = c
#c、d的值相同，指向的内存地址也相同。
print(c)
print(d)

c.append(300)
#c是列表，列表后面添加了一个元素。列表是可变数据类型，所以添加的数据还是在这个列表中，内存地址并没有发生变化，c的指向也没有变。
print(c)
#c的指向都没有变化，d的指向自然不会发生变化。所以c和d的值此时还是相同，内存地址也相同。都是[100,200,300]
print(d)

递归

函数调用自身就叫递归。

#计算从1乘以100的阶乘
#即1*2*3*4....*100，用递归的方式

def demo(num):
    if num>1:
        return num*demo(num-1)
    else:
        return 1

result = demo(100)
print(result)

匿名函数

匿名函数自带返回属性。

#常规函数使用方式
def demo(num1,num2):
    return num1+num2

print(demo(11,22))

#匿名函数使用方式
a = lambda a,b:a+b
print(a(2,3))

aCandy93

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python基础（1）

type(变量名):测试变量类型。\n:换行。“%d”%变量名:可直接替换为不同类型的变量名。 %d:整数变量，%s:字符串变量。input():输入框。运算符：%:取余。//：取整数(两数相除，无论是什么类型都只取整数)。**:乘幂。逻辑运算符：and:与。同JAVA中的&amp;符号。 or:或。同JAVA中的|符号。not:非。同JAVA中的...
复制链接

扫一扫