Explore
For Enterprise
Join for Free
Log In

艺术与人文
商务
计算机科学
数据科学
信息技术
健康
数学和逻辑
个人发展
物理科学与工程
社会科学
语言学习
學位
證書

瀏覽 Coursera 的全部課程

瀏覽
搜索
企業版
登錄
免費加入

Function Calls

Loading...

Python Basics

密歇根大学

4.8（1,545 個評分） | 31K 名學生已註冊

課程 1（共 5 門，Python 3 Programming 專項課程）

This course introduces the basics of Python 3, including conditional execution and iteration as control structures, and strings and lists as data structures. You'll program an on-screen Turtle to draw pretty pictures. You'll also learn to draw reference diagrams as a way to reason about program executions, which will help to build up your debugging skills. The course has no prerequisites. It will cover Chapters 1-9 of the textbook "Fundamentals of Python Programming," which is the accompanying text (optional and free) for this course. The course is for you if you're a newcomer to Python programming, if you need a refresher on Python basics, or if you may have had some exposure to Python programming but want a more in-depth exposition and vocabulary for describing and reasoning about programs. This is the first of five courses in the Python 3 Programming Specialization.

查看授課大綱

審閱

4.8（1,545 個評分）

5 stars
1,285 ratings
4 stars
228 ratings
3 stars
17 ratings
2 stars
10 ratings
1 star
5 ratings

PS

May 10, 2019

very nice explain of each and every topic in deeply nice textbook concepts with own e-notes its covered almost good content about basic python it is really good course for beginner in this :)

RD

Jul 05, 2019

Great course to learn the basics of Python. Loved the instructors and loved the detail-oriented lectures and learning material. Would highly recommend to anyone serious about learning Python.

從本節課中

General Introduction

In week one you will be introduced to programming in python through lectures and the Runestone textbook - an interactive online textbook built for this course. By the end of the module, you will have run your first python program, and learned how to draw images by writing a program.

Values and Data Types7:58

Operators and Operands7:08

Function Calls10:08

Type Conversion Functions5:48

Statements and Expressions8:27

More About Statements and Expressions6:43

Updating Variables7:24

Hard-Coding3:07

教學方

Paul Resnick
Michael D. Cohen Collegiate Professor
Steve Oney
Assistant Professor
Jaclyn Cohen
Lecturer

腳本

Welcome back.

One type of expression that you make right in Python is what's called the function

call expression.

So you can think of functions as boxes that

contain some machinery inside of them.

So I'm going to visually represent them here just using this gray box.

And you can think of a function as something that takes in some inputs.

So here, the inputs feed into the top here and

then these inputs go inside of this machinery.

This machinery does something with the inputs, and

then after it's done its work with the inputs, it spits out an output.

So visually again, you can think of it as working something like this.

So here we have a function, it takes in three inputs or arguments and

then it does work, and then it spits out an output or return value.

So let's watch that again.

So again, we have the function, and it takes in three inputs here or arguments,

then it does work, and then it spits out an output or a return value.

Now, let's translate this visual metaphor into actual working Python code.

Here's an example of how we would actually write a function call expression in

Python.

Suppose that we have a function named square and

our square function takes in one argument which is going to be a number.

And then it returns, or outputs, whatever that argument is squared.

So for example, if we say square and then open parenthesis and

we put our argument in between the parentheses here, so

this is called calling the square function with 4 as an argument.

So this is how we actually write that in Python again, we say square, or

whatever the name of the function is.

Then inside of parentheses immediately after the name of the function,

we pass in our arguments.

So the arguments go here.

And then the value of this overall expression, so

whatever the value of this expression is, is going to be the return value.

And so, in the case of square, if square squares whatever input or

arguments you give it, then the return value is going to be 16.

And this is what it looks like when we translate this Python

code into that visual representation that I just mentioned.

So we have the square function, again represented as a box, and the square

function in this case we suppose that it takes in one input or argument.

And if we pass in 4, it does some work, and it spits out an output or

return value of 16.

To watch that again, we pass in 4, the square function does some work,

and it computes an output or return value, in this case of 16.

And again, this is how we write that in Python code.

We say the name of the function, square, then open parentheses to say that we

want to call that function and then in between parentheses,

then we pass in whatever arguments we want our functions to take.

Now, Python functions can take one, two or any number of arguments or

inputs, but there's always exactly one output.

So, for example, here this function takes in three inputs, or arguments, but

it spits out one return value.

So again, functions always take any number of arguments, but

there's always one value of that function call.

So, let's look at a little bit more Python code and calling functions.

So, here on the first line we're actually calling two functions technically because

here print is the function that we're calling and

we're passing in as an argument to print, an expression which just so

happens to be another function call.

And this function call uses the square function that I just described.

So, again, the square function that I am describing,

this isn't a built-in with Python.

This is something that we defined for the purpose of the explaining function calls.

But we defined it in a way that it takes in one argument,

in this case square(3), and then it spits out that number squared.

So if we say, print out the value of square(3),

then this is going to print out the integer 9.

So let's see that in action.

So I'm going to comment out the rest of these lines and run my code.

And I can see that the value of this expression, square(3) is 9.

If we call a function, but we don't have a print statement, so let's suppose

that I say square(5), the value of this expression is going to be 10.

But you'll notice when I save and

run my code, it's not going to actually affect the output.

And that's because we never actually printed the value of square(5).

We just computed the value of square(5).

Excuse me, it's not 10, it's 25 of course.

So here the value of this is 25 but we never print out its value.

Now, let's suppose that we have another function, called sub.

So sub takes in two arguments.

So I can represent that visually like this.

So it takes in one and two arguments.

And just like every other function, it's going to spit out one returned value.

Now, let's suppose that sub subtracts the second argument from the first argument.

So, in other words, suppose if I passed in 6,

If I passed in 6 and 4,

Then my sub function is going to spit

out 2 because 6 minus 4 is 2.

So we would call the sub function by saying print out and then sub.

And then here you'll notice that we have two arguments and

we separate those arguments by a comma.

So you print out the value of sub(6, 4).

And we see that the value of this expression, sub(6, 4) is 2.

If we call it again, so if we call sub with arguments 5 and

9, then this is going to give us -4 because 5- 9 is -4.

We can also combine function calls with other operators including function calls.

So here if we print out the value of square(3) + 2.

Then Python is going to first compute the value of this overall expression by

evaluating the value of square(3) and then it's going to add the result of that to 2.

So Python is going to compute the value of square(3) and

it's going to get 9 and then it's going to compute the value of this expression,

which has a value, 2, because it's a literal expression.

And then it's going to add these numbers together to give us 11.

Now this expression on line 2 is much more complicated.

So here we can see that we're calling the sub function.

We're calling it with two arguments.

So the first argument is square(3), so this is arg 1,

the second argument is square(1 + 1), so this is arg 2.

Now, whenever Python calls a function call expression,

it needs to figure out what the values of the arguments are.

So Python kind of computes the values of a function call expression

from the inside out.

So it's going to go from the value of 1 + 1.

To the value of square(1+1) and then the value of square(3), and

then after it has the values for square(3) and square(1+1),

it's going to subtract those two values by calling the sub function.

So again, we're kind of going from the inside out to the next layer.

And then out to the next layer beyond that.

So when Python computes this,

it's going to first compute the value of square(1+1), or 2.

So it's going to compute the value of square(2), and that's going to give us 4.

It's going to compute the value of square(3), and that's going to give us 9.

And then it's going to compute the value of sub when called on 9 and

4, and that's going to give us 5.

So if I run my code, you'll see that we get

11 from line 1 and 5 from line 2.

Just to run through the exact steps that Python takes when computing the code on

line 2, Python first computes, what's the value of square(3)?

It gets 9, then it computes what's 1 + 1, and it gets 2.

Then it computes what's square(2), and it gets 4..

Then it subtracts 9 and 4 and gets 5 and that's what it ultimately prints out.

Now, one thing to note is that functions are objects in Python.

So if I print out what's the value of square,

then Python is going to tell me that square is a function.

So if I run my code, you can see that line 1 prints out function square.

In order to actually call the function or run that machinery,

we need to have the name of the function, and then open parenthesis and

pass in our arguments inside of those parentheses.

So in other words, we need to have open parentheses right after the name of

the function in order to say that we want to call the function,

we don't want to just reference that function object itself.

That's all for now, until next time.

探索我們的目錄

免費加入並獲得個性化推薦、更新和優惠。

Coursera 致力於普及全世界最好的教育，它與全球一流大學和機構合作提供在線課程。

© 2019 Coursera Inc. 保留所有權利。

通過 App Store 下載

通過 Google Play 獲取

Coursera
關於
管理團隊
工作機會
目錄
證書
MasterTrack™ 證書
學位
企業版
政府版

社區
Learners
Partners
Developers
Beta Testers
Translators

連接
博客
Facebook
領英
Twitter
Instagram
YouTube
技術博客

更多
條款
隱私
幫助
內容訪問
媒體
聯繫我們
目錄
附屬公司