python语言定义一个函数实现求各个数的倒数之和,Python基础1

1 新建一个pyhton工程：

2 pycharm的几个常见用法：

调整快捷键：

python支持的数据类型：

整型：不会溢出

浮点

字符串：在""或者‘’之间，所以pyhton没有字符类型。

''' ''' 之间可以放置多行文本。

多行文本的另外一个作用，作为函数的注释使用。

print('''hello

world''')

字符串可以进行格式化拼接：

“格式字符串”%(需要格式化的数据列表)

例如：

print ("hello %d %x %s %f"%(100,200,"nihao",10.5))

python是弱类型语言，定义变量的时候，不需要指定类型。

a = 100

print(a)

b = "hello world"

c = 10.5

a = "hello 15PB"

print(a)

python中的运算符：

基本和C/C++一致，不一样的地方有：

1 逻辑运算符 and or not

2 算数运算符中，"/"能够得到整数与小数部分。 '//'只能得到整数部分。

3 ** 幂运算

a = int(input("please input a number"))

b = int(input("please input a number"))

c = a**b

d= a/b

e = b//(a+1)

print(e)

输入一个数，判断是奇数还是偶数

num = int(input("请输入一个数："))

if num%2 == 0:

print("偶数")

else:

print("奇数")

输入1到7之间的数字，输入几就输出星期几：

day = int(input("请输入一个数："))

if day<=1 or day>=8:

print("你输入的有错误")

if day==1:

print("星期一")

elif day==2:

print("星期二")

​

​

字符串操作：

\1. 去掉字符串左边或者右边的某种字符

a = "   hello world   "

b = "***hello*world***"

c = ""

#1 去掉字符串中的某个字符

print(a.strip())

print(b.strip("*"))

print(b.lstrip("*"))

print(b.rstrip("*"))

\2. 切分

#1 切分

b = "he*llo*wor*ld"

print(b.split("*"))

\3. 查找某一个子串的位置

b = "he*llo*wor*ld"

#3 查找某一个子串的位置

print(b.find("wo"))

\4. 查找某一个子串的数量

b = "he*llo*wor*lld"

#3 查找某一个子串的数量

print(b.count("ll"))

\5. 拼接

#1 切分,以某一个字符为标准，将字符串拆分成列表。

b = "he*llo*wor*ld"

l = b.split("*")

print(l)

#2 拼接，将列表中的内容拼成一个字符串

print("".join(l))

\6. 判断字符串是否以一个子串开头，是否以一个子串结尾

startswith()

endswith()

\7. 求字符串长度

len

\8. 切片

a = "hello world"

b = a[6:11]

c = a[0:6]

print(c,b)

切片的格式

[开始:结束:步长]

a = "hello world"

b = a[6:11:2]

c = a[0:6]

print(c,b)

​

切片还可以负数

-1 代表的是最后一个元素，-2代表倒数第二个

a = "hello world"

b = a[-5:]

print(b)

列表(类似于vector，是动态数组)

[]

基本使用示例，和数组差不多。

li = [1,2,3,4,5]

print(li)

print(li[0])

print(li[1])

列表中的元素，不要求数据类型一致，可以存放任意类型的数据。

li = [100,10.5,"hello world",[1,2,3,4,5],200]

print(li[0])

print(li[1])

print(li[2][0])

print(li[3][2])

列表是一个类对象，有很多操作的函数：

1 求长度 len

li = [100,10.5,"hello world",[1,2,3,4,5],200]

print(len(li))

2 拼接

li1 = [100,10.5,[1,2,3,4,5],200]

li2 = ["hello"]

li3 = li1+li2

li4= 2*li3

print(li4)

\3. 求最大值和最小值

#求最大值和最小值需要注意，类型需要是能进行比较的

li1 = [100,105,60,200]

print(max(li1))

print(min(li1))

\4. 比较两个列表

import operator

li1 = [1,2,3,4,5]

li2 = [1,2,3,4]

li3 = [5]

li2 = li2+li3

​

print(operator.eq(li1,li2))

\5. 列表的内置函数

增

append 添加到最后

insert 在任意位置插入数据

li1 = [1,2,3,4,5]

​

li1.append(100)

li1.insert(2,50)

print(li1)

​

删

pop 按照位置删除

remove 按照元素删除

import operator

li1 = [1,2,3,4,5]

li1.pop(2)   #按位置删除

li1.remove(4) #按元素删除

print(li1)

​

改

[]

查

index 查找某一个元素出现的位置

import operator

li1 = [1,2,"hello",4,5]

​

print(li1.index("hello"))

​

其他函数：

计数 ： 某个元素出现的数量

count

排序：

sort 将列表中元素排序

反序：

reverse 将列表中元素顺序颠倒一下

追加：

extend 类似于+号的操作

li1 = [100,45,50,34,88,76,88]

print(li1.count(88))

li1.reverse()

print(li1)

li1.sort()

print(li1)

li1.reverse()

print(li1)

​

列表也是可以切片的，切片的规则和字符串是一样的

import operator

li1 = [100,45,50,34,88,76,88]

li2 = li1[0:3]

print(li2)

​

元组(类似于const的vector)

()

基本使用和列表是一样的，但是元组的元素是不能修改的。

字典(类似于map)

字典的每一个元素，都是由键和键值组成的键值对：

键是不可改变的量：整型 字符串 元组，不可以是列表

键值是随意的：可以是列表

di = {1:"hello",2:"world","hello":[12,3]}

print(di[1])

di[1] = "nihao"

print(di[1])

print(di["hello"])

增

setdefault：设置某一个键的键值，如果不存在这个键，就添加一个

删

del 直接删掉某一个元素

改

[键] = obj

查

get 获取某一个键的键值

has_key 查看是否存在这个键

其他：

keys() 得到所有的键 配合循环，可以遍历字典

import operator

di = {1:"hello",2:"world","hello":[12,3]}

print(di.keys())

values() 得到所有的键值

深拷贝和浅拷贝的问题：

python中的标识符，都是存储的地址

li = [1,100,3,4,5]

li1 = li.copy()

li[0] = "hello"

​

print(li1)

快速赋值的问题，python的元组和字典都可以快速赋值：

import operator

#元组或者列表能够整体赋值

li = (1,100,3,4,5)

a,b,c,d,e = li

print(c)

​

#不使用中间变量，交换两个数

a = 10

b = 20

a,b = [b,a]#(b,a)

print(a)

循环结构：

while的使用逻辑和C/C++一致

for一般用于遍历序列

遍历列表：

#1. 遍历列表

li = [10,20,15,30,45]

#for循环，每一次循环都会从列表中选出一个元素，一般用于遍历

for ele in li:

print(ele*2)

#同时输出索引和数值

for index,ele in enumerate(li):

print(index,ele)

遍历字典：

di = {100:"hello",200:"world",10:[1,2,3]}

for key in di.keys():

print(key,di[key])

循环可以跟else：

如果循环不是通过break跳出的，那么就会执行else的语句。

循环如果是正常结束的，就会执行else中的语句。

di = {100:"hello",200:"world",10:[1,2,3]}

for key in di.keys():

if key == 200:

print(key,di[key])

break

else:

print("循环正常退出")

​

python中函数的用法：

def add(a,b):

return a+b

​

def print_num(a):

print(a)

​

m = add(10,20)

print(m)

m = print_num(100)

print(m)

​

由于函数，可以传递任意类型，所以有时候，会在函数内部检测一下类型

def add(a,b):

if type(a)==int and type(b)==int:

return a+b

return None

m = add(10,[1,2,3])

print(m)

关键字传参：

def add(a,b):

print("a的值是%d"%(a))

return a+b

return None

m = add(10,20)

#可以直接指定参数名去传参，这种方式叫做关键字传参

n = add(b=100,a =200)

​

局部变量与全局变量:

通常定义在函数内的是局部变量，定义在函数外的是全局变量。

在函数内如果要使用全局变量，需要加上global进行声明：

sum = 10

​

def add(a):

#如果你想在函数内部使用全局变量,加global进行声明

global sum

for ele in a:

sum+=1

return sum

m = add("hello")

print(m,sum)

​

python允许在函数内部定义全局变量

def add(a):

#如果你想在函数内部使用全局变量,加global进行声明

sum = 0

global abc #这里就是声明abc是全局变量，可以在函数外部访问到

abc= 20

for ele in a:

sum+=1

return sum

m = add("hello")

print(m,abc)

可以查看到当前环境下的所有局部变量和全局变量

def add(a):

#如果你想在函数内部使用全局变量,加global进行声明

sum = 0

global abc

abc= 20

for ele in a:

sum+=1

print(locals())

return sum

m = add("hello")

print(globals())

实现列表去重

List=[1,2,3,4,4,2,6,3,3,2]

List2=list(set(List))

print(List2)

输出1！+2！+3！+4！+5！的值

def fun (n):

if n ==1:

return 1

elif n == 2:

return 2

else:

return n*fun(n-1)

​

print(fun(1)+fun(2)+fun(3)+fun(4)+fun(5))

水仙花数

i=153

a = i % 10         #个位数值

b = (i // 10) % 10 #十位数值

c = (i // 100) % 10 #百位数值

d = a*a*a + b*b*b + c*c*c

print(d)

打印菱形图案

def fun(n):

for i in range(1, 2*n, 2):

j = int(((2*n-1) - i) / 2)

​

print(' ' * j + '*' * i + ' ' * j)

​

for i in range((2*n-1)-2, 0, -2):

j = int(((2*n-1) - i) / 2)

​

print(' ' * j + '*' * i + ' ' * j)

fun(10)

冒泡排序

List=[20,30,40,3,6,47,25,77,15]

​

for i in range(len(List)-1):

for j in range(len(List)-1-i):

if List[j] < List[j+1]:

List[j], List[j+1] = List[j+1], List[j]

​

print(List)

杨辉三角

def Yanghui():

n=[1]

while True:

yield n

n.append(0)

n=[n[i]+n[i-1]for i in range(len(n))]

def fun(n):

for i in Yanghui():

print(i)

n-=1

if n== 0:

break

fun(10)

标签：Python,基础,li,li1,print,100,列表,hello

来源： https://www.cnblogs.com/ltyandy/p/10969380.html